Forgee library v 1.0.1

--[[
Forgee library v 1.0.1
To use these functions paste: dofile("Forgee.lua")
at the top of your script.

Forum thread: http://forums.xenobot.net/showthread.php?2392-Lua-functions-by-Forgee
Facebook: http://facebook.com/forgee.xenobot
]]

----------------------------------------------------------------------------
------------------------------ Self Class ----------------------------------
----------------------------------------------------------------------------

-- getMonstersAround(4, "Frost Dragon", "Frost Dragon Hatchling")
function getMonstersAround(radius, ...)
    local t = {...}
    local monsters = {}
    for i = CREATURES_LOW, CREATURES_HIGH do
        local creature = Creature.GetFromIndex(i) -- Let's find us a creature //TODO: Find a way to read additional info correctly (hp, speed, outfit etc).
        if (creature:isValid()) and creature:ID() ~= Self.ID() then -- Make sure it's valid and don't count ourselves.
            if (creature:isOnScreen() and creature:isVisible() and creature:isAlive()) then -- We want to see the creature.
                if not creature:isPlayer() then -- And it must not be a player, aren't we picky?
                    local name = creature:Name()
                    if (creature:DistanceFromSelf() <= radius) then -- Is the creature close enough to be considered?
                        if (#t > 0 and table.contains(t, name)) or (#t == 0) then -- If we have a monster list, we look for our creature there.
                            table.insert(monsters, creature)
                        end
                    end
                end
            end
        end
    end
    return monsters
end
--[[
Example use for exori: (Note: Added exori() function to library.)

dofile("Forgee.lua")
local radius = 1 -- Radius to consider
local min = 2 -- Minimum number of monsters to hit.
local spell = "exori" -- Spell to cast.
local mana = 120 -- Minimum mana to cast spell.
local monsters = {"Frost Dragon", "Frost Dragon Hatchling"}
function exori()
    local m = getMonstersAround(radius, unpack(monsters))
    if #m >= min then
        Self.Cast(spell, mana)
        wait(1100, 1800)
    end
end

while (true) do
    exori()
end
]]

-- getPlayersAround(7, "DarkstaR", "Syntax")
function getPlayersAround(radius, ...)
    local t = {...}
    local players = {}
    if (radius == 0) then
        radius = 8
    end
    for i = CREATURES_LOW, CREATURES_HIGH do
        local creature = Creature.GetFromIndex(i)
        if (creature:isValid()) and creature:ID() ~= Self.ID() then
            if (creature:isOnScreen() and creature:isVisible() and creature:isAlive()) then
                if creature:isPlayer() then
                    local name = creature:Name()
                    if (creature:DistanceFromSelf() <= radius) then
                        if (not table.contains(t, name)) then -- If we have a white list, we look for the player there.
                            table.insert(players, creature)
                        end
                    end
                end
            end
        end
    end
    return players
end
--[[
Usage:
We can find all info the bot can get about a creature.
If you enter names after the radius it will work as a "whitelist".

players = getPlayersAround(8, "DarkstaR", "Syntax")
if #players > 0 then
    for i = #players do
        creature = players[i]
        if creature:HealthPercent() < 60 then
            ~do something
        end
    end
end
]]

-- Same as getPlayersAround, but gets players from other floors too.
-- xrayPlayersAround(6)
function xrayPlayersAround(radius, ...)
    local t = {...}
    local players = {}
    if (radius == 0) then
        radius = 8
    end
    for i = CREATURES_LOW, CREATURES_HIGH do
        local creature = Creature.GetFromIndex(i)
        if (creature:isValid()) and creature:ID() ~= Self.ID() then
            if creature:isVisible() and creature:isAlive() then
                if creature:isPlayer() then
                    local name = creature:Name()
                    local selfpos = Self.Position()
                    local creaturepos = creature:Position()
                    local distance = math.max(math.abs(selfpos.x - creaturepos.x), math.abs(selfpos.y - creaturepos.y))
                    if (distance <= radius) then
                        if not table.contains(t, name) then
                            table.insert(players, creature)
                        end
                    end
                end
            end
        end
    end
    return players
end


function monstersAround(radius, ...) -- Count monsters around. monstersAround(5, "Frost Dragon") will count only Frost Dragons within a 5 sqm radius.
    if getMonstersAround(radius, ...) then
        return #getMonstersAround(radius, ...)
    else
        return 0
    end
end

function playersAround(radius, ...) -- Count players around. Names are excluded from the count.
    if getPlayersAround(radius, ...) then
        return #getPlayersAround(radius, ...)
    else
        return 0
    end
end


-- Can be used for any circular aoe spell such as UE, Divine Caldera, etc.
-- exori(1, 3, "exori", 120, false, "Frost Dragon", "Frost Dragon Hatchling")
function exori(radius, num, spell, mana, hitPlayers, ...)
    local monsters = {...}
    if monstersAround(radius, unpack(monsters)) >= num then
        if not hitPlayers then
            if playersAround(radius + 2) == 0 then
                Self.Cast(spell, mana)
            end
        else
            Self.Cast(spell, mana)
        end
        wait(1100, 1800)
    end
    wait(200,500)
end
--[[Example Script ] --
dofile("Forgee.lua")
local radius = 1 -- Radius to consider
local num = 2 -- Minimum number of monsters to hit.
local spell = "exori" -- Spell to cast.
local mana = 120 -- Minimum mana to cast spell.
local monsters = {"Frost Dragon", "Frost Dragon Hatchling"}
local hitPlayers = false -- false will not cast the spell if there are players in the affected nearby (radius+1). true will execute regardless of other players, only recommended for Optional pvp.

while (true) do
    exori(radius, num, spell, mana, hitPlayers, monsters) -- All waiting is handled by the main function.
end
]]

Self.GetMonstersAround = getMonstersAround
Self.MonstersAround = monstersAround
Self.GetPlayersAround = getPlayersAround
Self.PlayersAround = playersAround
Self.Exori = exori

--[[
Backpacks inside one another should be the same kind.
closeBackpacks() -- optional id of cascaded backapacks
]]
function closeBackpacks()
    local displayName = "CloseBackpacks"
    local tmpBP = Container.GetFirst()
    local cascaded = {}
    while tmpBP:isOpen() do
        for spot = 0, tmpBP:ItemCount() do
            local item = tmpBP:GetItemData(spot)
            if item.id == tmpBP:ID() then
                table.insert(cascaded, tmpBP:ID())
                tmpBP = tmpBP:GetNext()
            end
        end
        tmpBP = Container.GetFirst()
        if not table.contains(cascaded, tmpBP:ID()) or tmpBP:ItemCount() == 0 then -- Backpack is main or last cascaded. Closing...
            Self.UseItem(tmpBP:ID())
            wait(500, 900)
        end
        if #cascaded > 0 then -- Any cascaded backpacks?
            for i = 1, #cascaded do
                if tmpBP:ID() == cascaded[i] then -- Found cascaded backpack.
                    if tmpBP:ItemCount() > 0 then -- Backpack contains atleast one item, check for another bp.
                        for spot = 0, tmpBP:ItemCount() do
                            local item = tmpBP:GetItemData(spot)
                            if item.id == tmpBP:ID() then -- Found anoter cascade bp, opening...
                                tmpBP:UseItem(spot, true)
                                break
                            end
                        end
                    end
                end
            end
        end
        wait(500, 900)
        tmpBP = Container.GetFirst() -- Get a new bp to check.
        if tmpBP:ID() == 0 then -- No more open backpacks.
            print("All backpacks were successfully closed.")
        end
    end
    return true
end

-- openBackpacks(id[, {"Parent Name", id})
-- openBackpacks() -- Will open the bp in your backpack slot.
-- openBackpacks({"Backpack", 9602}) -- Will open an orange bp (9602) inside a Backpack.
-- openBackpacks(9602, {"Orange Backpack", 8860}) -- Will first open an orage bp inside the first container/main bp. Then opens a Brocade Backpack inside the Orange Backpack.
function openBackpacks(...)
    local displayName = "OpenBackpacks"
    local backpacks = {...}
    Self.UseItem(Self.Backpack().id) -- Open main backpack.
    print("Opening main backpack.")
    wait(500, 900)
    main = Container.GetFirst()
    if #backpacks > 0 then
        for i = 1, #backpacks do
            if type(backpacks[i]) == 'table' then -- Is parent container specified?
                tmpBP = Container.GetByName(backpacks[i][1])
                for spot = 0, tmpBP:ItemCount() do
                    item = tmpBP:GetItemData(spot)
                    if item.id == backpacks[i][2] then
                        tmpBP:UseItem(spot)
                        print("Opening backpack from list. " .. backpacks[i][1] .. ", " .. backpacks[i][2])
                        wait(500, 800)
                    end
                end
            else -- If there is no parent specified we will use the main bp.
                for spot = 0, main:ItemCount() do
                    item = main:GetItemData(spot)
                    if item.id == backpacks[i] then
                        main:UseItem(spot)
                        print("Opening backpack from list, " .. backpacks[i])
                        wait(500, 800)
                    end
                end
            end
        end
        local indexes = Container.GetIndexes()
        for i = 1, #indexes do
            if type(backpacks[i]) == "table" then
                if Container.GetFromIndex(indexes[i]):ID() ~= backpacks[i][1] then
                    return false
                end
            else
                if Container.GetFromIndex(indexes[i]):ID() ~= backpacks[i] then
                    return false
                end
            end
        end
        return true
    end
end

--[[
Returns a table containing the ids of opened backpacks in order.
open = getOpenBackpacks()
open[1] -> first backpack
open[2] -> second backpack, etc.
]]
function getOpenBackpacks()
    local indexes = Container.GetIndexes() -- Find index for all open backpacks
    local open = {} -- Create a place to store our open backpacks
    for i = 1, #indexes do -- Search all open backpacks
        tmpBP = Container.GetFromIndex(indexes[i])
        table.insert(open, tmpBP:ID()) -- Store this backpack
    end
    return open -- Return found backpacks
end

--[[
resetBackpacks([tries])
Checks if all backpacks were reopened correctly. If not it will start over up to a maximum number of times defined by 'tries' or 3 if omitted.
]]
function resetBackpacks(tries)
    setWalkerEnabled(false)
    local open = getOpenBackpacks() -- Save a list of open backpacks
    local tries = 3 -- Give the script 3 tries to achieve a successful reset.
    repeat
        closeBackpacks() -- Close all backpacks
        wait(600, 800) -- wait a little bit
        local reopen = openBackpacks(unpack(open)) -- I store the return from openBackpacks, true if successfull, false otherwise
        if tries == 0 then -- Check how many tries function has left
            print("BackpackReset failed!") -- Tell the user reset has failed
            return false
        end
        tries = tries - 1 -- One try has been spent
    until reopen -- If reopen is true it means all backpacks were opened successfully and function is done
    print("BackpackReset was successfull!") -- Tell user reset was successful
    setWalkerEnabled(true)
    return true
end

Self.CloseBackpacks = closeBackpacks
Self.OpenBackpacks = openBackpacks
Self.ResetBackpacks = resetBackpacks
Self.GetOpenBackpacks = getOpenBackpacks

--teleportWalker(32111, 33106, 7, labelName, "Teleport1" "PassedTeleport1")
-- Please do not omit labelName (exactly like it is) as it is needed for the function to know which label the walker is on.
function teleportWalker(x, y, z, labelName, label1, label2)
    if not label1 then
        label1 = "Teleport"
    end
    if not label2 then
        label2 = "PassedTeleport"
    end
    if labelName == label1 then
        wait(2000)
        gotoLabel(label2)
    elseif labelName == label2 then
        delayWalker(2000)
        if Self.Position().x ~= x or Self.Position().y ~= y or Self.Position().z ~= z then
            gotoLabel(label1)
        end
    end
end

Self.TelepotWalker = teleportWalker

-- openDoor(direction[, key])
-- also accepts position as a table, openDoor({x, y, z}) or as normal x, y, z
function openDoor(x, y, z, keyid)
    if not x then -- assumes doorpos is 1sqm ahead in the direction the char is facing
        pos = Self.LookPos(1)
    elseif type(x) == "table" then
        pos = {x = x[1], x = x[2], z = x[3]}
        keyid = y
    elseif x < 50 then
        pos = getPositionFromDirection(Self.Position(), x, 1)
        keyid = y
    else
        pos = {x = x, y = y, z = z}
    end
    local door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
    if table.contains(CLOSED_DOORS, door.id) then -- door is closed
        local tries = 0
        if keyid then
            local spot = getSpotByID(keyid)
            if spot then
                repeat
                    if tries >= 3 then
                        print("OpenDoor: Failed to open door!")
                        return false
                    end
                    Container:UseItemWithGround(spot, pos.x, pos.y, pos.z)
                    wait(500, 800)
                    door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
                    tries = tries + 1
                until table.contains(OPENED_DOORS, door.id)
            else
                print("OpenDoor: Could not find key %s.", keyid)
                return false
            end
        else
            repeat
                if tries >= 3 then
                    print("OpenDoor: Failed to open door!  Is it locked?")
                    return false
                end
                Self.UseItemFromGround(pos.x, pos.y, pos.z)
                wait(500, 800)
                door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
                tries = tries + 1
            until table.contains(OPENED_DOORS, door.id)
        end
    end
    return true
end

-- Same usage as openDoor
function closeDoor(x, y, z, keyid)
    if not x then -- assumes doorpos is 1sqm ahead in the direction the char is facing
        pos = Self.LookPos(1)
    elseif type(x) == "table" then
        pos = {x = x[1], x = x[2], z = x[3]}
        keyid = y
    elseif x < 50 then
        pos = getPositionFromDirection(Self.Position(), x, 1)
        keyid = y
    else
        pos = {x = x, y = y, z = z}
    end
    local door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
    if table.contains(OPENED_DOORS, door.id) then -- door is open
        if keyid then
            spot = getSpotByID(keyid)
            repeat
                Container:UseItemWithGround(spot, pos.x, pos.y, pos.z)
                wait(500, 800)
                door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
            until table.contains(CLOSED_DOORS, door.id)
        else
            repeat
                Self.UseItemFromGround(pos.x, pos.y, pos.z)
                wait(500, 800)
                door = Map.GetTopUseItem(pos.x, pos.y, pos.z)
            until table.contains(CLOSED_DOORS, door.id)
        end
    end
    return true
end

Self.BuyItemsUpTo = function(item, count)
    amount = Self.ItemCount(item)
    needed = math.abs(count - amount)
    if type(item) ~= "number" then
        item = Item.GetID(item)
    end
    if amount < count then
        return Self.ShopBuyItem(item, needed)
    else
        return 1
    end
end

Self.SellItemsDownTo = function(item, count)
    amount = Self.ItemCount(item)
    sell = math.abs(amount - count)
    if type(item) == "string" then
        item = Item.GetID(item)
    end
    while amount > count do
        Self.ShopSellItem(item, sell)
        amount = Self.ItemCount(item)
        sell = math.abs(amount - count)
    end
    return 1
end

Self.ShopBuyItemsUpTo = Self.BuyItemsUpTo
Self.ShopSellItemsDownTo = Self.SellItemsDownTo

function skinCreature(tool, range, ...)
    if type(tool) == "string" then
        tool = Item.GetID(tool)
    end
    if Self.ItemCount(tool) == 0 then
        print("Could not find %s in any open container.", Item.GetName(tool))
        return false
    end
    local bodies = {...}
    for i = 1, #bodies do
        local pos = Map.FindUseItem(bodies[i])
        if pos ~= 0 then
            if Self.DistanceFromPosition(pos.x, pos.y, pos.z) <= range then
                setWalkerEnabled(false)
                setLooterEnabled(false)
                while getDistanceBetween(Self.Position(), pos) > 1 do
                    Self.UseItemWithGround(tool, pos.x, pos.y, pos.z)
                    wait(1500, 2500)
                end
                setWalkerEnabled(true)
                setLooterEnabled(true)
                return 1
            end
        end
    end
    return 0
end

Self.Skin = function (range, ...)
    return skinCreature(5908, range, ...)
end

Self.Stake = function (range, ...)
    return skinCreature(5942, range, ...)
end

Self.Fish = function (range, ...)
    return skinCreature(3483, range, ...)
end

Self.Target = function ()
    return Creature.GetByID(Self.TargetID())
end

Self.AutoFish = function (miss)
    local function findWater()
        local FISH_POS = {}
        local EMPTY_POS = {}
        local WATER_FISH = {4597, 4598, 4599, 4601, 4602}
        local WATER_EMPTY = {4603, 4604, 4605, 4606, 4607, 4608, 4609, 4610, 4611, 4612, 4613}
        for x = -7, 7 do
            for y = -5, 5 do
                tile = Map.GetTopUseItem(Self.Position().x + x, Self.Position().y + y, Self.Position().z)
                if table.contains(WATER_FISH, tile.id) then
                    table.insert(FISH_POS, {x = Self.Position().x + x, y = Self.Position().y + y, z = Self.Position().z})
                elseif table.contains(WATER_EMPTY, tile.id) then
                    table.insert(EMPTY_POS, {x = Self.Position().x + x, y = Self.Position().y + y, z = Self.Position().z})
                end
            end
        end
        return FISH_POS, EMPTY_POS
    end

    if Self.ItemCount(3492) > 0 then
        local oldCount = Self.ItemCount(3492)
        if not pos or pos.x ~= Self.Position().x or pos.y ~= Self.Position().y then
            fish, empty = findWater()
            pos = Self.Position()
        end
        if miss and type(miss) ~= 'boolean' then
            print("AutoFish: Invalid agument. Valid arguments are 'true' or 'false'.")
            return false
        end
        if miss then
            for i = 1, #empty do
                table.insert(fish, empty[i])
            end
        end
        if #fish > 0 then
            local spot = math.random(1, #fish)
            local tile = Map.GetTopUseItem(fish[spot].x, fish[spot].y, fish[spot].z)
            Self.UseItemWithGround(Item.GetID("Fishing rod"), fish[spot].x, fish[spot].y, fish[spot].z)
            sleep(500)
            if Self.ItemCount(3492) < oldCount then
                result = 2
            else
                result = 1
            end
        end
        wait(500, 800)
    end
    return result or 0
end

Self.ReachDepot = function (tries)
    local tries = tries or 3
    setWalkerEnabled(false)
    local DepotIDs = {3497, 3498, 3499, 3500}
    local DepotPos = {}
    for i = 1, #DepotIDs do
        local dps = Map.GetUseItems(DepotIDs[i])
        for j = 1, #dps do
            table.insert(DepotPos, dps[j])
        end
    end
    local function gotoDepot()
        local pos = Self.Position()
        print("Depots found: " .. tostring(#DepotPos))
        for i = 1, #DepotPos do
            location = DepotPos[i]
            Self.UseItemFromGround(location.x, location.y, location.z)
            wait(1000, 2000)
            if Self.DistanceFromPosition(pos.x, pos.y, pos.z) >= 1 then
                wait(5000, 6000)
                if Self.DistanceFromPosition(location.x, location.y, location.z) == 1 then
                    setWalkerEnabled(true)
                    return true
                end
            else
                print("Something is blocking the path. Trying next depot.")
            end
        end
        return false
    end

    repeat
        reachedDP = gotoDepot()
        if reachedDP then
            return true
        end
        tries = tries - 1
        sleep(100)
        print("Attempt to reach depot was unsuccessfull. " .. tries .. " tries left.")
    until tries <= 0

    return false
end

----------------------------------------------------
-------------------[ Map Tools ]--------------------
----------------------------------------------------

Map.FindUseItem = function (id)
    if type(id) == "string" then
        id = Item.GetID(id)
    end
    local pos = Self.Position()
    for x = -7, 7 do
        for y = -5, 5 do
            if Map.GetTopUseItem(pos.x + x, pos.y + y, pos.z).id == id then
                itemPos = {x = pos.x + x, y = pos.y + y, z = pos.z}
                return itemPos
            end
        end
    end
    return 0
end

Map.FindMoveItem = function (id)
    if type(id) == "string" then
        id = Item.GetID(id)
    end
    local pos = Self.Position()
    for x = -7, 7 do
        for y = -5, 5 do
            if Map.GetTopMoveItem(pos.x + x, pos.y + y, pos.z).id == id then
                itemPos = {x = pos.x + x, y = pos.y + y, z = pos.z}
                return itemPos
            end
        end
    end
    return 0
end

Map.GetUseItems = function (id)
    if type(id) == "string" then
        id = Item.GetID(id)
    end
    local pos = Self.Position()
    local store = {}
    for x = -7, 7 do
        for y = -5, 5 do
            if Map.GetTopUseItem(pos.x + x, pos.y + y, pos.z).id == id then
                itemPos = {x = pos.x + x, y = pos.y + y, z = pos.z}
                table.insert(store, itemPos)
            end
        end
    end
    return store
end

Map.GetMoveItems = function (id)
    if type(id) == "string" then
        id = Item.GetID(id)
    end
    local pos = Self.Position()
    local store = {}
    for x = -7, 7 do
        for y = -5, 5 do
            if Map.GetTopMoveItem(pos.x + x, pos.y + y, pos.z).id == id then
                itemPos = {x = pos.x + x, y = pos.y + y, z = pos.z}
                table.insert(store, itemPos)
            end
        end
    end
    return store
end

----------------------------------------------------
-------------------[ Item Tools ]-------------------
----------------------------------------------------

-- getSpotByID(id[, container]) Container name/index is optional.
function getSpotByID(id, container)
    if container then
        if type(container) == "string" then
            cont = Container.GetByName(container)
        elseif type(container) == "number" then
            cont = Container.GetFromIndex(container)
        end
    else
        cont = Container.GetFirst()
    end
    while cont:isOpen() do
        for spot = 0, cont:ItemCount() do
            item = cont:GetItemData(spot)
            if item.id == id then
                return spot, cont
            end
        end
        if container then
            print("GetSpotByID: Item of id " .. id .. " could not be found in " .. cont:Name() .. ".")
            return false
        else
            cont = cont:GetNext()
        end
    end
    print("GetSpotByID: Item of id " .. id .. " could not be found in any open container.")
    return false
end

Item.GetSpotByID = getSpotByID

function getItemFromSpot(spot, container)
    cont = Container.GetByName(container)
    item = cont:GetItemData(spot)
    return item.id
end

-------------------------------------------------------------
-----------------------[ War tools ]-------------------------
-------------------------------------------------------------
-- [NOT TESTED] --
function warEnemies(range)
    p = getPlayersAround(range)
    enemies = {}
    for i = 1, #p do
        if p[i]:isWarEnemy() then
            table.insert(enemies, p[i])
        end
    end
    return #enemies
end

function warAllies(range)
    p = getPlayersAround(range)
    allies = {}
    for i = 1, #p do
        if p[i]:isWarAlly() then
            table.insert(allies, p[i])
        end
    end
    return #allies
end

function getWarAllies(range)
    p = getPlayersAround(range)
    allies = {}
    for i = 1, #p do
        if p[i]:isWarAlly() then
            table.insert(allies, p[i])
        end
    end
    if #allies > 0 then
        return allies
    else
        return false
    end
end

function getWarEnemies(range)
    p = getPlayersAround(range)
    enemies = {}
    for i = 1, #p do
        local player = p[i]
        if player:isWarEnemy() then
            table.insert(enemies, player)
        end
    end
    if #enemies > 0 then
        return enemies
    else
        return false
    end
end

Self.WarEnemies = warEnemies
Self.WarAllies = warAllies
Self.GetWarEnemies = getWarEnemies
Self.GetWarAllies = getWarAllies