[Problem] XenoBot

[cycu1233]

Witam mam xenobota i ściągnąłem skrypta z forum xenobota i dodalem go do folderu scripst i chcę go odpalić a tu mi wyskakuje takie coś:

XenoScript Error:
Script: [Mage] Yalahar Giant Spiders.lua
Error: cannot open C:\Users\Marcin\Documents\XenoBot\Scripts\[JX] Library.lua: No such file or directory
This is an error with user-input and should not be reported as a bug with XenoBot.

Wiecie co z tym może być nie tak?

[vegeta4545]

Witam mam xenobota i ściągnąłem skrypta z forum xenobota i dodalem go do folderu scripst i chcę go odpalić a tu mi wyskakuje takie coś:

XenoScript Error:

Script: [Mage] Yalahar Giant Spiders.lua

Error: cannot open C:\Users\Marcin\Documents\XenoBot\Scripts\[JX] Library.lua: No such file or directory

This is an error with user-input and should not be reported as a bug with XenoBot.

Wiecie co z tym może być nie tak?

 

 

witoj ja mojom wiedze na tym temot zbieroł żech tczy dni

 

ale żech postanowił cie pomuc

 

robisz tok

to poniżej kopiujesz

--[[
Forgee library v 1.1.0
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 function.
end
]]
 
Self.GetMonstersAround = getMonstersAround
Self.MonstersAround = monstersAround
Self.GetPlayersAround = getPlayersAround
Self.PlayersAround = playersAround
Self.Exori = exori
 
--[ Container functions ]--
--[[
Since we now can close a container instead of using hotkeys, cascaded backpacks no longer has to be the same colour. Yay!
You can close specific backpacks by entering the index, id or name of backpacks to close.
]]
function closeBackpacks(...)
        local backpacks = {...}
        local indexes = Container.GetIndexes()
        if #backpacks > 0 then
                for i = #backpacks, 1, -1 do
                        if type(backpacks[i]) == "string" then
                                tmpBP = Container.GetByName(backpacks[i])
                        elseif backpacks[i] < 18 then
                                tmpBP = Container.GetFromIndex(backpacks[i])
                        else
                                tmpBP = Container.GetByName(Item.GetName(backpacks[i]))
                        end
                        tmpBP:Close()
                        wait(200, 500)
                end
        else
                Self.CloseContainers()
        end
end
 
--[[
openBackpacks() -- Will open the bp in your backpack slot.
openBackpacks({9602, 0}) -- Will open an orange bp (9602) inside a your main (first open) backpack.
openBackpacks(9602, {8860, 1}) -- Will first open an orage bp inside the first container/main bp if open. If Main bp is not open it will open that first. Then opens a Brocade Backpack in the second open container ().
]]
function openBackpacks(...)
        local backpacks = {...} -- List of backpacks to open.
    local open = Container.GetIndexes() -- List of already open backpacks.
    local main = Container.GetFirst() -- First open container is assumed to be main backpack (will be 0 if no container is open).
    local toOpen = #backpacks -- Number of backpacks we need to open (used to check success).
        local defaultOpen = {} -- A place to store the backpacks to open by container:OpenChildren(), if any.
        local bps = {} -- A place to store the backpacks to open by container:UseItem(), if any. Why not always use :OpenChildren()? This way I can open bps by their relative position instead of id, so you don't have to worry about colours anymore.
    if main:ID() == 0 then -- If no backpack is open, we need to open main.
                if backpacks[1] ~= Self.Backpack().id then
                        toOpen = toOpen + 1
                end
                repeat -- Open main backpack.
                        wait(200, 600)
                until Self.UseItemFromEquipment("backpack") > 0
                wait(500)
                main = Container.GetFirst()
    end
        for i = 1, #backpacks do
                if type(backpacks[i]) == "table" then
                        if backpacks[i][1] > 16 then
                                if backpacks[i][2] ~= main:Index() then
                                        main = Container.GetFromIndex(backpacks[i][2])
                                        for spot = 0, main:ItemCount()-1 do
                                                local item = main:GetItemData(spot)
                                                if Item.isContainer(item.id) then
                                                        table.insert(bps, spot)
                                                end
                                        end
                                        main:UseItem(bps[backpacks[i][1]])
                                        wait(500, 900)
                                end
                        elseif backpacks[i][1] ~= main:ID() then
                                main = Container.GetFromIndex(backpacks[i][2])
                                main:OpenChildren(backpacks[i][1])
                                wait(500, 900)
                        end
                elseif backpacks[i] < 16 then
                        if i == 1 then
                                for spot = 0, main:ItemCount()-1 do
                                        local item = main:GetItemData(spot)
                                        if Item.isContainer(item.id) then
                                                table.insert(bps, spot)
                                        end
                                end
                                for _, num in ipairs(backpacks) do
                                        main:UseItem(bps[num])
                                        wait(500, 900)
                                end
                                break
                        end
                elseif backpacks[i] ~= main:ID() then
                        table.insert(defaultOpen, backpacks[i])
                end
        end
        if #defaultOpen > 0 then
                main:OpenChildren(unpack(defaultOpen))
        end
        wait(400)
        if #open + toOpen == #Container.GetIndexes() then
                return true
        end
        return false
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(reset)
If reset is specified it will reset the number of backpacks specified. resetBackpacks(1) will reset the last opened backpack, resetBackpacks(2) the last 2 etc.
Empty argument resets all open backpacks.
Checks if all backpacks were reopened correctly. If not it will start over up to 3 times. If it failed after 3 tries it returns false (true if it succeeds).
]]
function resetBackpacks(reset)
    setWalkerEnabled(false)
    local open = {} -- Create a table to hold backpack list
        local close = {}
    local indexes = Container.GetIndexes() -- Get ids of open backpacks.
    if reset then
        if reset > 0 and reset < #indexes then
                        for i = (#indexes-reset)+1, #indexes do
                                table.insert(open, indexes[i])
            end
        else
                        for i = 2, #indexes do -- If 'reset' is above the number of open backpacks we should reset all.
                                table.insert(open, indexes[i])
                        end
        end
    else
        for i = 2, #indexes do -- If 'reset' is nil (empty argument) we should reset all backpacks.
                        table.insert(open, indexes[i])
                end
    end
    local tries = 3 -- Give the script 3 tries to achieve a successful reset.
    repeat
        if reset then
                        if reset > 0 and reset < #indexes then
                                closeBackpacks(unpack(open)) -- Close selected backpacks
                        else
                                Self.CloseContainers() -- Close all backpacks.
                        end
        else
            Self.CloseContainers() -- Close all backpacks
        end
        wait(600, 800) -- wait a little while
        local reopen = openBackpacks(unpack(open)) -- I store the return from openBackpacks, true if successfull, false otherwise
        if tries == 0 then -- Check how many tries the function has left
            print("BackpackReset failed!") -- Tell the user that reset has failed
            return false
        end
        tries = tries - 1 -- One try has been spent
                wait(100,200)
    until reopen -- If reopen is true it means all backpacks were opened successfully and function is done
    setWalkerEnabled(true)
    return true
end
 
Self.SellItemsDownTo = function(item, count)
        return Self.ShopSellItem(Self.ShopGetItemSaleCount(item) - count)
end
 
Self.BuyItemsUpTo = Self.ShopBuyItemsUpTo
Self.ShopSellItemsDownTo = Self.SellItemsDownTo
 
----------------------------------------------------
-----------[ Working with ground items ]------------
----------------------------------------------------
 
-- 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
 
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.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
                        local 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
 
-------------------------------------------------------------
-----------------------[ 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

do ostatnej liniki (sie znoczy wszyćko

otwierosz folder

C:\Users\TWOJO_NAZWA_UZYTKOWNIKA\Documents\XenoBot

wchodzisz we

C:\UsersTWOJO_NAZWA_UZYTKOWNIKA/Documents\XenoBot\Scripts

torzysz rzech tom nowy dokumynt textowy

i wklejosz to co żech skopiowoł

a całość zapisujesz jako

frogee.lua

 

i ci działo elegancko , moch nadzije żech nie przeszkodzo ci mój odpoł z pisanim

[cycu1233]

Wielkie THX!

[zbyszek123789]

Witam mam problem z załadowaniem skrypta do Xenobota nie mam pojęcia jak to załadować, potrzebuję też poradnika do xenobota,!

[vegeta4545]

http://torg.pl/showthread.php?439257-XenoBot-Oficjalny-temat&p=7388258&viewfull=1#post7388258

 

http://www.youtube.com/watch?v=nsA40smugzE

 

http://forums.xenobot.net/showthread.php?4192-Xenobot-Scripter-Tutorial-How-to-load-scripts

 

http://torg.pl/showthread.php?439257-XenoBot-Oficjalny-temat&p=7388258&viewfull=1#post7388258

[maciej12312]

sory ze odkopuje ale mam problem:

Gram na jednym ots 10.77 uzywam xeno i expie na Ironblight i Orewalkerach. Ironbrighty mi otwiera wszystkie a Orewalkera nie otwiera podalby mi ktos skrypta na otwieranie cial o id?