ESOUI SVN EsoHeadMarkers

EHM = {
        ["skyshard"]    = "EsoUI/Art/Inventory/inventory_tabicon_quest_up.dds",
        ["chest"] = "EsoUI/Art/Inventory/inventory_tabicon_misc_up.dds"
        }
EHM.material = {
        {pinType = "mining", texture = "EsoUI/Art/MapPins/AvA_mine_Neutral.dds", tooltip = "Ore", size = 20 },
        {pinType = "clothing", texture = "EsoUI/Art/Characterwindow/gearslot_tabard.dds", tooltip = "Clothing Material", size = 20 },
        {pinType = "rune", texture = "EsoUI/Art/Crafting/enchantment_tabicon_essence_down.dds", tooltip = "Runestone", size = 20 },
        {pinType = "alchemy", texture = "EsoUI/Art/Crafting/alchemy_tabicon_reagent_down.dds", tooltip = "Alchemy Ingredient", size = 20 },
        {pinType = "provisioning", texture = "EsoheadMarkers/clothing.dds", tooltip = "Provision Material", size = 20 },
        {pinType = "wood", texture = "EsoUI/Art/MapPins/AvA_lumbermill_Neutral.dds", tooltip = "Wood", size = 20 }
}

EHM.layouts = {}

local function EHMChestCallback( g_mapPinManager )
        if not ZO_WorldMap_IsPinGroupShown("chest") then
                return
        end
        local zone = GetMapName()
        local chests = EH.savedVars["chest"].data[zone]
        if not chests then
                return
        end
        for _,chest in pairs(chests) do
                g_mapPinManager:CreatePin( _G["chest"], { chest[1], chest[2] }, chest[1], chest[2] )
        end

end

function EHMNotFound( zone, x, y)
        local foundShards = EHM.foundShards.zones[ zone ]
        local minFound, minShard
        local minDist = math.huge

        if not foundShards then
                return true
        end

        --get closest already collected shard
        for _, shard in pairs( foundShards ) do
                if zo_abs(shard[1] - x) + zo_abs(shard[2] - y) < minDist then
                        minFound = shard
                        minDist = zo_abs(shard[1] - x) + zo_abs(shard[2] - y)
                end
        end

        if not minFound then
                return true
        end

        --get closest shard
        minDist = math.huge

        for _, shard in pairs( EHMShards[ zone ] ) do
                if zo_abs(shard[1] - minFound[1]) + zo_abs(shard[2] - minFound[2]) < minDist then
                        minShard = shard
                        minDist = zo_abs(shard[1] - minFound[1]) + zo_abs(shard[2] - minFound[2])
                end
        end

        if not minShard then
                return true
        end
        -- if current shard and closest shard are the same, it is already collected
        return not (minShard[1] == x and minShard[2] == y)
end

local function EHMFoundSkyshardCallback( g_mapPinManager )
        if not ZO_WorldMap_IsPinGroupShown("found_skyshard") then
                return
        end
        local zone = GetMapName()
        local skyshards = EHMShards[ zone ]
        if not skyshards then
                return
        end

        for _,shard in pairs(skyshards) do
                if not EHMNotFound(zone, shard[1], shard[2]) then
                        g_mapPinManager:CreatePin( _G["found_skyshard"], { shard[1], shard[2] }, shard[1], shard[2] )
                end
        end
end

local function EHMSkyshardCallback( g_mapPinManager )
        if not ZO_WorldMap_IsPinGroupShown("skyshard") then
                return
        end
        local zone = GetMapName()
        local skyshards = EHMShards[ zone ]
        if not skyshards then
                return
        end

        for _,shard in pairs(skyshards) do
                if EHMNotFound(zone, shard[1], shard[2]) then
                        g_mapPinManager:CreatePin( _G["skyshard"], { shard[1], shard[2] }, shard[1], shard[2] )
                end
        end
end

local function Old_EHMSkyshardCallback( g_mapPinManager )
        local zone = GetMapName()
        local skyshards = EH.savedVars["skyshard"].data[zone]
        if not skyshards then
                return
        end
        for _,shard in pairs(skyshards) do
                g_mapPinManager:CreatePin( _G["skyshard"], { shard[1], shard[2] }, shard[1], shard[2] )
        end

end

local function EHMHarvestCallback( materialId, g_mapPinManager )
        if not ZO_WorldMap_IsPinGroupShown(EHM.material[materialId].pinType) then
                return
        end
        local zone = GetMapName()
        local harvestNodes = EH.savedVars["harvest"].data[zone]
        if not harvestNodes then
                return
        end
        harvestNodes = harvestNodes[materialId]
        if harvestNodes then
                for _, node in pairs(harvestNodes) do
                        g_mapPinManager:CreatePin( _G[EHM.material[materialId].pinType], { node[1], node[2] }, node[1], node[2] )
                end
        end
end

function EHMFindShard(mapName, x, y)
        if not EHM.foundShards.zones[ mapName ] then
                EHM.foundShards.zones[ mapName ] = {}
        end
        local list = EHM.foundShards.zones[ mapName ]
        --if  not (list[ #list ][1] == x and list[ #list ][2] == y) then
        list[ #list + 1 ] = { x, y }
        --end
end

EHM.Log = EH.Log
EHM.LogCheck = EH.LogCheck

function EH.Log( type, nodes, ... )
        EHM.Log( type, nodes, ... )
        if type == "harvest" then
                EHM.MapPins:RefreshPins( EHM.material[nodes[2]].pinType )
        elseif type == "skyshard" then
                EHM.MapPins:RefreshPins( "skyshard" )
                EHM.MapPins:RefreshPins( "found_skyshard" )
        end
end

function EH.LogCheck( type, nodes, x, y, ... )
        local result = EHM.LogCheck( type, nodes, x, y )
        if type == "skyshard" then
                SetMapToPlayerLocation()
                local mapName = GetMapName()
                local mapType = GetMapType()
                local playerX, playerY = GetMapPlayerPosition( "player" )
                EHMFindShard(mapName, playerX, playerY)
                while mapType == MAPTYPE_SUBZONE do --if inside a dungeon
                        if MapZoomOut() ~= SET_MAP_RESULT_MAP_CHANGED then --go back
                                break
                        end
                        mapType = GetMapType()
                end
                if mapType == MAPTYPE_ZONE then
                        mapName = GetMapName()
                        playerX, playerY = GetMapPlayerPosition( "player" )
                        EHMFindShard(mapName, playerX, playerY)
                end
        end
        return result
end

local function EHMPinSize(input)
        local category, size = zo_strsplit(" ", input)
        size = tonumber(size)
        if category == nil or size == nil or size < 16 or size > 64 or not (category == "skyshard" or category == "chest" or category == "harvest")  then
                d("/pinsize [category] [size]")
                d("[category]: skyshard, chest, harvest")
                d("[size]: between 16 and 64")
                d("example: /pinsize harvest 32")
                return
        end
        if  category == "harvest" then
                for _, pinType in pairs( EHM.material ) do
                        if EHM.layouts[ pinType.pinType ] then
                                EHM.layouts[ pinType.pinType ].size = size
                        end
                end
        else
                EHM.layouts[category].size = size
        end
        EHM.MapPins:RefreshPins()
end

local function EHMOnLoad(eventCode, addOnName )
        if addOnName ~= "EsoheadMarkers" then
                return
        end

        SLASH_COMMANDS["/pinsize"] = EHMPinSize

        EHM.foundShards = ZO_SavedVars:New("EsoheadMarkers_SavedVariables", 1, "skyshard", { zones = {} })
        EHM.layouts = ZO_SavedVars:New("EsoheadMarkers_SavedVariables", 1, "layout")

        EHMInitSkyshards()
        EHM.MapPins = CustomMapPins:New()
        --
        if not EHM.layouts["skyshard"] then
                EHM.layouts["skyshard"] = { level = 20, texture = EHM["skyshard"], size = 40 }
        end
        EHM.MapPins:CreatePinType( "skyshard",
                EHM.layouts["skyshard"],
                { creator = function(pin)
                        local str
                        if EHM.debug then
                                str = "Mark this Skyshard as collected!"
                        else
                                str = "Uncollected Skyshard"
                        end
                        InformationTooltip:AddLine(str) end,
                        tooltip = InformationTooltip },
                EHMSkyshardCallback
        )

        if not EHM.layouts["found_skyshard"] then
                EHM.layouts["found_skyshard"] = { level = 20, texture = EHM["skyshard"], size = 32 }
        end
        EHM.MapPins:CreatePinType( "found_skyshard",
                EHM.layouts["found_skyshard"],
                { creator = function(pin)
                        local str
                        if EHM.debug then
                                str = "Mark this Skyshard as uncollected!"
                        else
                                str = "Collected Skyshard"
                        end
                        InformationTooltip:AddLine(str) end,
                        tooltip = InformationTooltip },
                EHMFoundSkyshardCallback
        )

        if not EHM.layouts["chest"] then
                EHM.layouts["chest"] = { level = 20, texture = EHM["chest"], size = 32 }
        end
        EHM.MapPins:CreatePinType( "chest",
                EHM.layouts["chest"],
                "Chest",
                EHMChestCallback
        )

        for id, material in pairs( EHM.material ) do
                if id ~= 5 then --not sure how to handle provision
                        local i = id
                        local t = material.texture
                        local s = material.size
                        if not EHM.layouts[material.pinType] then
                                EHM.layouts[material.pinType] = { level = 20, texture = t, size = s }
                        end
                        EHM.MapPins:CreatePinType( material.pinType,
                                EHM.layouts[material.pinType],
                                material.tooltip,
                                function(g_mapPinManager)
                                EHMHarvestCallback( i, g_mapPinManager )
                                end
                        )
                end
        end

        EHMInitializeDebug()
        EHMInitializeCompass()

        EHMInitializeFilters()

        EHM.MapPins:RefreshPins()
end

EVENT_MANAGER:RegisterForEvent("EsoheadMarkers", EVENT_ADD_ON_LOADED, EHMOnLoad)