RNGHelper

Alles in einer Datei, am Ende habt ihr 3, 2 LUA´s, 1 XML Datei

------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
Format LUA - Name config2          Speicherort: Windower/addons/libs
------------------------------------------------------------------------------------------------------------------------------------------


--[[
    Functions that facilitate loading, parsing, manipulating and storing of config files.
]]

local config = {}

_libs = _libs or {}
_libs.config = config
_libs.tables = _libs.tables or require('tables')
_libs.sets = _libs.sets or require('sets')
_libs.lists = _libs.lists or require('lists')
_libs.strings = _libs.strings or require('strings')
_libs.xml = _libs.xml or require('xml')
_libs.files = _libs.files or require('files')

local error = error or print+{'Error:'}
local warning = warning or print+{'Warning:'}
local notice = notice or print+{'Notice:'}
local log = log or print

-- Map for different config loads.
local settings_map = T{}

--[[ Local functions ]]

local parse
local merge
local settings_table
local settings_xml
local nest_xml
local table_diff

-- Loads a specified file, or alternatively a file 'settings.xml' in the current addon/data folder.
function config.load(filepath, defaults)
    if type(filepath) ~= 'string' then
        filepath, defaults = 'data/settings.xml', filepath
    end

    local confdict_mt = getmetatable(defaults) or _meta.T
    local settings = setmetatable(table.copy(defaults or {}), {__class = 'Settings', __index = function(t, k)
        if config[k] ~= nil then
            return config[k]
        end

        return confdict_mt.__index[k]
    end})

    -- Settings member variables, in separate struct
    local meta = {}
    meta.file = _libs.files.new(filepath, true)
    meta.original = T{global = table.copy(settings)}
    meta.chars = S{}
    meta.comments = {}
    meta.refresh = T{}
    meta.cdata = S{}

    settings_map[settings] = meta

    -- Load addon config file (Windower/addon/<addonname>/data/settings.xml).
    if not meta.file:exists() then
        config.save(settings, 'all')
    end

    return parse(settings)
end

-- Reloads the settings for the provided table. Needs to be the same table that was assigned to with config.load.
function config.reload(settings)
    if not settings_map[settings] then
        error('Config reload error: unknown settings table.')
        return
    end

    parse(settings)

    for t in settings_map[settings].refresh:it() do
        t.fn(settings, unpack(t.args))
    end
end

-- Resolves to the correct parser and calls the respective subroutine, returns the parsed settings table.
function parse(settings)
    local parsed = T{}
    local err
    local meta = settings_map[settings]

    if meta.file.path:endswith('.json') then
        parsed = _libs.json.read(meta.file)

    elseif meta.file.path:endswith('.xml') then
        parsed, err = _libs.xml.read(meta.file)

        if not parsed then
            error(err or 'XML error: Unknown error.')
            return settings
        end

        parsed = settings_table(parsed, settings)
    end

    -- Determine all characters found in the settings file.
    meta.chars = parsed:keyset() - S{'global'}
    meta.original = T{}

    if table.empty(settings) then
        for char in (meta.chars + S{'global'}):it() do
            meta.original[char] = table.update(table.copy(settings), parsed[char], true)
        end

        local full_parsed = parsed.global
        local player = windower.ffxi.get_player()
        if player then
            full_parsed = full_parsed:update(parsed[player.name:lower()], true)
        end

        return settings:update(full_parsed, true)
    end

    -- Update the global settings with the per-player defined settings, if they exist. Save the parsed value for later comparison.
    for char in (meta.chars + S{'global'}):it() do
        meta.original[char] = merge(table.copy(settings), parsed[char], char)
    end
    for char in meta.chars:it() do
        meta.original[char] = table_diff(meta.original.global, meta.original[char]) or T{}
    end

    local full_parsed = parsed.global

    local player = windower.ffxi.get_player()
    if player then
        full_parsed = full_parsed:update(parsed[player.name:lower()], true)
    end

    return merge(settings, full_parsed)
end

-- Merges two tables like update would, but retains type-information and tries to work around conflicts.
function merge(t, t_merge, path)
    path = type(path) == 'string' and T{path} or path

    local keys = {}
    for key in pairs(t) do
        keys[tostring(key):lower()] = key
    end

    for lkey, val in pairs(t_merge) do
        local key = keys[lkey:lower()]
        if not key then
            if type(val) == 'table' then
                t[lkey] = setmetatable(table.copy(val), getmetatable(val) or _meta.T)
            else
                t[lkey] = val
            end

        else
            local err = false
            local oldval = rawget(t, key)
            local oldtype = type(oldval)

            if oldtype == 'table' and type(val) == 'table' then
                t[key] = merge(oldval, val, path and path:copy() + key or nil)

            elseif oldtype ~= type(val) then
                if oldtype == 'table' then
                    if type(val) == 'string' then
                        -- Single-line CSV parser, can possible refactor this to tables.lua
                        local res = {}
                        local current = ''
                        local quote = false
                        local last
                        for c in val:gmatch('.') do
                            if c == ',' and not quote then
                                res[#res + 1] = current
                                current = ''
                                last = nil
                            elseif c == '"' then
                                if last == '"' then
                                    current = current .. c
                                    last = nil
                                else
                                    last = '"'
                                end

                                quote = not quote
                            else
                                current = current .. c
                                last = c
                            end
                        end
                        res[#res + 1] = current

                        -- TODO: Remove this after a while, not standard compliant
                        -- Currently needed to not mess up existing settings
                        res = table.map(res, string.trim)

                        if class then
                            if class(oldval) == 'Set' then
                                res = S(res)
                            elseif class(oldval) == 'List' then
                                res = L(res)
                            elseif class(oldval) == 'Table' then
                                res = T(res)
                            end
                        end
                        t[key] = res

                    else
                        err = true

                    end

                elseif oldtype == 'number' then
                    local testdec = tonumber(val)
                    local testhex = tonumber(val, 16)
                    if testdec then
                        t[key] = testdec
                    elseif testhex then
                        t[key] = testhex
                    else
                        err = true
                    end

                elseif oldtype == 'boolean' then
                    if val == 'true' then
                        t[key] = true
                    elseif val == 'false' then
                        t[key] = false
                    else
                        err = true
                    end

                elseif oldtype == 'string' then
                    if type(val) == 'table' and not next(val) then
                        t[key] = ''
                    else
                        t[key] = val
                        err = true
                    end

                else
                    err = true
                end

            else
                t[key] = val
            end

            if err then
                if path then
                    warning('Could not safely merge values for \'%s/%s\', %s expected (default: %s), got %s (%s).':format(path:concat('/'), key, class(oldval), tostring(oldval), class(val), tostring(val)))
                end
                t[key] = val
            end
        end
    end

    return t
end

-- Parses a settings struct from a DOM tree.
function settings_table(node, settings, key, meta)
    settings = settings or T{}
    key = key or 'settings'
    meta = meta or settings_map[settings]

    local t = T{}
    if node.type ~= 'tag' then
        return t
    end

    if not node.children:all(function(n)
        return n.type == 'tag' or n.type == 'comment'
    end) and not (#node.children == 1 and node.children[1].type == 'text') then
        error('Malformatted settings file.')
        return t
    end

    -- TODO: Type checking necessary? merge should take care of that.
    if #node.children == 1 and node.children[1].type == 'text' then
        local val = node.children[1].value
        if node.children[1].cdata then
            meta.cdata:add(key)
            return val
        end

        if val:lower() == 'false' then
            return false
        elseif val:lower() == 'true' then
            return true
        end

        local num = tonumber(val)
        if num ~= nil then
            return num
        end

        return val
    end

    for child in node.children:it() do
        if child.type == 'comment' then
            meta.comments[key] = child.value:trim()
        elseif child.type == 'tag' then
            key = child.name:lower()
            local childdict
            if table.containskey(settings, key) then
                childdict = table.copy(settings)
            else
                childdict = settings
            end
            t[child.name:lower()] = settings_table(child, childdict, key, meta)
        end
    end

    return t
end

-- Writes the passed config table to the spcified file name.
-- char defaults to windower.ffxi.get_player().name. Set to "all" to apply to all characters.
function config.save(t, char)
    if char ~= 'all' and not windower.ffxi.get_info().logged_in then
        return
    end

    char = (char or windower.ffxi.get_player().name):lower()
    local meta = settings_map[t]

    if char == 'all' then
        char = 'global'
    elseif char ~= 'global' and not meta.chars:contains(char) then
        meta.chars:add(char)
        meta.original[char] = T{}
    end

    meta.original[char]:update(t)

    if char == 'global' then
        meta.original = T{global = meta.original.global}
        meta.chars = S{}
    else
        meta.original.global:amend(meta.original[char], true)
        meta.original[char] = table_diff(meta.original.global, meta.original[char]) or T{}

        if meta.original[char]:empty(true) then
            meta.original[char] = nil
            meta.chars:remove(char)
        end
    end

    meta.file:write(settings_xml(meta))
end

-- Returns the table containing only elements from t_new that are different from t and not nil.
function table_diff(t, t_new)
    local res = T{}
    local cmp

    for key, val in pairs(t_new) do
        cmp = t[key]
        if cmp ~= nil then
            if type(cmp) ~= type(val) then
                warning('Mismatched setting types for key \''..key..'\':', type(cmp), type(val))
            else
                if type(val) == 'table' then
                    if class(val) == 'Set' or class(val) == 'List' then
                        if not cmp:equals(val) then
                            res[key] = val
                        end
                    elseif table.isarray(val) and table.isarray(cmp) then
                        if not table.equals(cmp, val) then
                            res[key] = val
                        end
                    else
                        res[key] = table_diff(cmp, val)
                    end
                elseif cmp ~= val then
                    res[key] = val
                end
            end
        end
    end

    return not table.empty(res) and res or nil
end

-- Converts a settings table to a XML representation.
function settings_xml(meta)
    local lines = L{}
    lines:append('<?xml version="1.1" ?>')
    lines:append('<settings>')

    local chars = (meta.original:keyset() - S{'global'}):sort()
    for char in (L{'global'} + chars):it() do
        if char == 'global' and meta.comments.settings then
            lines:append('    <!--')
            local comment_lines = meta.comments.settings:split('\n')
            for comment in comment_lines:it() do
                lines:append('        %s':format(comment:trim()))
            end

            lines:append('    -->')
        end

        lines:append('    <%s>':format(char))
        lines:append(nest_xml(meta.original[char], meta))
        lines:append('    </%s>':format(char))
    end

    lines:append('</settings>')
    lines:append('')
    return lines:concat('\n')
end

-- Converts a table to XML without headers using appropriate indentation and comment spacing. Used in settings_xml.
function nest_xml(t, meta, indentlevel)
    indentlevel = indentlevel or 2
    local indent = (' '):rep(4*indentlevel)

    local inlines = T{}
    local fragments = T{}
    local maxlength = 0        -- For proper comment indenting
    local keys = set.sort(table.keyset(t))
    local val
    for _, key in ipairs(keys) do
        val = t[key]
        if type(val) == 'table' and not (class(val) == 'List' or class(val) == 'Set') then
            fragments:append('%s<%s>':format(indent, key))
            if meta.comments[key] then
                local c = '<!-- %s -->':format(meta.comments[key]:trim()):split('\n')
                local pre = ''
                for cstr in c:it() do
                    fragments:append('%s%s%s':format(indent, pre, cstr:trim()))
                    pre = '\t '
                end
            end
            fragments:append(nest_xml(val, meta, indentlevel + 1))
            fragments:append('%s</%s>':format(indent, key))

        else
            if class(val) == 'List' then
                val = list.format(val, 'csv')
            elseif class(val) == 'Set' then
                val = set.format(val, 'csv')
            elseif type(val) == 'table' then
                val = table.format(val, 'csv')
            elseif type(val) == 'string' and meta.cdata:contains(tostring(key):lower()) then
                val = '<![CDATA[%s]]>':format(val)
            else
                val = tostring(val)
            end

            if val == '' then
                fragments:append('%s<%s />':format(indent, key))
            else
                fragments:append('%s<%s>%s</%s>':format(indent, key, meta.cdata:contains(tostring(key):lower()) and val or val:xml_escape(), key))
            end
            local length = fragments:last():length() - indent:length()
            if length > maxlength then
                maxlength = length
            end
            inlines[fragments:length()] = key
        end
    end

    for frag_key, key in pairs(inlines) do
        if meta.comments[key] then
            fragments[frag_key] = '%s%s<!-- %s -->':format(fragments[frag_key], ' ':rep(maxlength - fragments[frag_key]:trim():length() + 1), meta.comments[key])
        end
    end

    return fragments:concat('\n')
end

function config.register(settings, fn, ...)
    local args = {...}
    local key = tostring(args):sub(8)
    settings_map[settings].refresh[key] = {fn=fn, args=args}
    return key
end

function config.unregister(settings, key)
    settings_map[settings].refresh[key] = nil
end

local function reload_settings()
    for _, settings in settings_map:it() do
        config.reload(settings)
    end
end

windower.raw_register_event('load', reload_settings)
windower.raw_register_event('logout', reload_settings)
windower.raw_register_event('login', reload_settings)

return config

--[[
Copyright © 2013-2015, Windower
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
    * Neither the name of Windower nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL Windower BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
]]



------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
Format LUA - Name rnghelper          Speicherort:  Windower/addons/gearswap/libs
------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
require('queues')
res = require('resources')
packets = require('packets')
config = require('config2')

local self = windower.ffxi.get_player().id
local index = windower.ffxi.get_player().index
local target = nil
local completion = false
local turn = false
local mode = nil
local weaponskill = nil
local assist = nil
local cooldowns = {}
local settings = config.load('libs/rnghelper_settings.xml')
local cooldown = 0
local queue = Q{}
local pending = nil
local enabled = true
local pet = nil
local cancel = false
local timeout = 6.0
local timestamp = os.time()

local action_events = {
    [2] = 'mid /ra',
    [3] = 'mid /ws',
    [4] = 'mid /ma',
    [5] = 'mid /item',
    [6] = 'pre /ja',
    [7] = 'pre /ws',
    [8] = 'pre /ma',
    [9] = 'pre /item',
    [12] = 'pre /ra',
    [13] = 'mid /petws',
    [14] = 'pre /ja',
    [15] = 'pre /ja',
}

local terminal_action_events = {
    [2] = 'mid /ra',
    [3] = 'mid /ws',
    [4] = 'mid /ma',
    [5] = 'mid /item',
    [6] = 'pre /ja',
    [13] = 'mid /petws',
}

local action_interrupted = {
    [78] = 78,
    [84] = 84,
}

local action_message_interrupted = {
    [16] = 16,
    [62] = 62,
}

local action_message_unable = {
    [12] = 12,
    [17] = 17,
    [18] = 18,
    [34] = 34,
    [35] = 35,
    [40] = 40,
    [47] = 47,
    [48] = 48,
    [49] = 49,
    [55] = 55,
    [56] = 56,
    [71] = 71,
    [72] = 72,
    [76] = 76,
    [78] = 78,
    [84] = 84,
    [87] = 87,
    [88] = 88,
    [89] = 89,
    [90] = 90,
    [91] = 91,
    [92] = 92,
    [94] = 94,
    [95] = 95,
    [96] = 96,
    [104] = 104,
    [106] = 106,
    [111] = 111,
    [128] = 128,
    [154] = 154,
    [155] = 155,
    [190] = 190,
    [191] = 191,
    [192] = 192,
    [193] = 193,
    [198] = 198,
    [199] = 199,
    [215] = 215,
    [216] = 216,
    [217] = 217,
    [218] = 218,
    [219] = 219,
    [220] = 220,
    [233] = 233,
    [246] = 246,
    [247] = 247,
    [307] = 307,
    [308] = 308,
    [313] = 313,
    [315] = 315,
    [316] = 316,
    [325] = 325,
    [328] = 328,
    [337] = 337,
    [338] = 338,
    [346] = 346,
    [347] = 347,
    [348] = 348,
    [349] = 349,
    [356] = 356,
    [410] = 410,
    [411] = 411,
    [428] = 428,
    [429] = 429,
    [443] = 443,
    [444] = 444,
    [445] = 445,
    [446] = 446,
    [514] = 514,
    [516] = 516,
    [517] = 517,
    [518] = 518,
    [523] = 523,
    [524] = 524,
    [525] = 525,
    [547] = 547,
    [561] = 561,
    [568] = 568,
    [569] = 569,
    [574] = 574,
    [575] = 575,
    [579] = 579,
    [580] = 580,
    [581] = 581,
    [649] = 649,
    [660] = 660,
    [661] = 661,
    [662] = 662,
    [665] = 665,
    [666] = 666,
    [700] = 700,
    [701] = 701,
    [717] = 717,
}

local function load_profile(name, set_to_default)
    local profile = settings.profiles[name]
    for k, v in pairs(profile.cooldowns) do
        cooldowns["\/%s":format(k)] = v
    end
    weaponskill = profile.weaponskill
    mode = profile.mode
    turn = profile.turn
    if set_to_default then
        settings.default = name
        settings:save('all')
    end
end

local function save_profile(name)
    local profile = {}
    profile.cooldowns = {}
    for k, v in pairs(cooldowns) do
        profile.cooldowns[k:sub(2)] = v
    end
    profile.weaponskill = weaponskill
    profile.mode = mode
    profile.turn = turn
    settings.profiles[name] = profile
    settings.default = name
    settings:save('all')
end

local function heading_difference(h, a)
    if (h > 0 and a > 0) or (h < 0 and a < 0) then
        return math.abs(h - a)
    else
        local d = math.abs(a - h)
        if d > math.pi then
            if h > 0 then
                d = h - a - 2 * math.pi
            else
                d = h - a + 2 * math.pi
            end
        end
        return math.abs(d)
    end
end

local function turn_away(player, mob)
    local dx = player.x - mob.x
    local dy = player.y - mob.y
    local away = math.atan(-dy/dx)
    if (dx >= 0) then
        windower.ffxi.turn(away)
    else
        if away >= 0 then
            away = away - math.pi
        else
            away = away + math.pi
        end
        windower.ffxi.turn(away)
    end
    local p = packets.parse('outgoing', windower.packets.last_outgoing(0x15))
    local h = p['Rotation'] * 2 * math.pi/255
    if h > math.pi then
        h = h - 2 * math.pi
    end
    return heading_difference(h, away) >= 0.785398
end

local function able_to_use_action()
    if pending.action_type == 'Ability' then
        return windower.ffxi.get_ability_recasts()[res.job_abilities[pending.id].recast_id] == 0
    elseif pending.action_type == 'Magic' then
        return windower.ffxi.get_spell_recasts()[res.spells[pending.id].recast_id] == 0
    end
    return true
end

local function able_to_use_weaponskill()
    return windower.ffxi.get_player().vitals.tp >= 1000
end

local function execute_pending_action()
    cooldown = cooldowns[pending.prefix]
    if pending.prefix == '/range' then
        windower.chat.input("%s %d":format(pending.prefix, pending.target))
    else
        windower.chat.input("%s \"%s\" %d":format(pending.prefix, pending.english, pending.target))
    end
end

local function process_pending_action()
    if turn and (pending.prefix == '/range' or pending.prefix == '/weaponskill') then
        local player = windower.ffxi.get_mob_by_id(self)
        local mob = windower.ffxi.get_mob_by_id(pending.target)
        cancel = turn_away(mob, player)
    end
    if pending.prefix == '/weaponskill' then
        if not able_to_use_weaponskill() then
            queue:insert(1, pending)
            pending = {
                ['prefix'] = '/range',
                ['english'] = 'Ranged',
                ['target'] = pending.target,
            }
        end
        execute_pending_action()
    elseif not able_to_use_action() then
        windower.add_to_chat(200, "Rnghelper : Aborting %s - Ability not ready.":format(pending.english))
        completion = true
        process_queue()
    else
        execute_pending_action()
    end
end

function process_queue()
    if completion then
        pending = nil
        completion = false
    end
    if pending then
    elseif not queue:empty() then
        pending = queue:pop()
    elseif target then
        if weaponskill and able_to_use_weaponskill() then
            pending = {
                ['prefix'] = '/weaponskill',
                ['english'] = weaponskill,
                ['target'] = target,
                ['action_type'] = 'Ability',
            }
        else
            pending = {
                ['prefix'] = '/range',
                ['english'] = 'Ranged',
                ['target'] = target,
                ['action_type'] = 'Ranged Attack',
            }
        end
    end
    if pending then
        process_pending_action()
    end
end

local function handle_interrupt()
    completion = true
    windower.send_command('@wait %f;gs rh process':format(cooldown))
end

local function add_spell_to_queue(spell)
    queue:push({
        ['prefix'] = spell.prefix,
        ['english'] = spell.english,
        ['target'] = spell.target.id,
        ['id'] = spell.id,
        ['action_type'] = spell.action_type,
    })
end

local function check_timeout()
    local current_time = os.time()
    if pending and (current_time - timestamp) >= timeout then
        timestamp = current_time
        if pending.english then
            windower.add_to_chat(167, "Timed out attempting to %s - Retrying":format(pending.english))
        end
        process_queue()
    end
end

function filter_precast(spell, spellMap, eventArgs)
    if (pending and
        pending.prefix == spell.prefix and
        pending.english == spell.english and
        pending.target == spell.target.id) or (not enabled) then
        if enabled and turn and cancel then
            eventArgs.cancel = true
            cancel_spell()
            windower.send_command('@wait 0.1;gs rh process')
        else
            timestamp = os.time()
            coroutine.schedule(check_timeout, timeout)
        end
    else
        eventArgs.cancel = true
        cancel_spell()
        if pending then
            if spell.english == 'Ranged' then
                target = spell.target.id
                completion = true
                process_queue()
            else
                add_spell_to_queue(spell)
            end
        else
            add_spell_to_queue(spell)
            process_queue()
        end
    end
end

local function monitor_target(id, data, modified, injected, blocked)
    if (id == 0xe) and target then
        local p = packets.parse('incoming', data)
        if (p.NPC == target) and ((p.Mask % 8) > 3) then
            if not (p['HP %'] > 0) then
                target = nil
                pending = nil
                completion = false
                queue:clear()
            end
        end
    end
end

local function handle_incoming_action_packet(id, data, modified, injected, blocked)
    if id == 0x28 and enabled then
        local p = packets.parse('incoming', data)
        if ((p.Actor == self) or (p.Actor == pet)) and action_events[p.Category] then
            if action_interrupted[p['Target 1 Action 1 Message']] then
                handle_interrupt()
            elseif p.Param == 28787 then
            elseif terminal_action_events[p.Category] then
                if pending and pending.prefix == '/pet' and not (res.job_abilities[p.Param].type == 'PetCommand') then
                    if p.Actor == pet then
                        handle_interrupt()
                    end
                else
                    handle_interrupt()
                end
            end
        elseif assist and (not target) and (p.Category == 2) then
            local player = windower.ffxi.get_mob_by_id(p.Actor)
            if player.name == assist then
                local empty = queue:empty()
                queue:push({
                    ['prefix'] = '/range',
                    ['english'] = 'Ranged',
                    ['target'] = p['Target 1 ID'],
                    ['action_type'] = 'Ranged Attack',
                })
                if empty then
                    process_queue()
                end
            end
        end
    end
end

local function handle_incoming_action_message_packet(id, data, modified, injected, blocked)
    if id == 0x29 and enabled then
        local p = packets.parse('incoming', data)
        if (p.Actor == self) then
            if action_message_interrupted[p.Message] then
                handle_interrupt()
            elseif action_message_unable[p.Message] then
                windower.send_command('@wait 0;gs rh process')
            end
        end
    end
end

local function handle_outgoing_action_packet(id, data, modified, injected, blocked)
    if id == 0x1a and enabled then
        local p = packets.parse('outgoing', data)
        if p.Category == 16 then
            target = p.Target
            cooldown = cooldowns['/range']
        end
    end
end

local function acquire_pet(id, data)
    if id == 0x68 then
        local p = packets.parse('incoming', data)
        if p['Owner ID'] == self then
            pet = p['Target ID']
        end
    end
end

local function clear()
    target = nil
    pending = nil
    completion = false
    queue:clear()
end

register_unhandled_command(function (...)
    local commands = {...}
    if commands[1] and commands[1]:lower() == 'rh' then
        if commands[2] and commands[2]:lower() == 'process' then
            process_queue()
        elseif commands[2] and commands[2]:lower() == 'set' then
            if commands[3] then
                windower.add_to_chat(200, "Rnghelper : Setting weaponskill to %s":format(commands[3]))
                weaponskill = commands[3]
            else
                windower.add_to_chat(200, "Rnghelper : Clearing weaponskill.")
                weaponskill = nil
            end
        elseif commands[2] and commands[2]:lower() == 'assist' then
            if commands[3] then
                windower.add_to_chat(200, "Rnghelper : Assisting %s":format(commands[3]))
                assist = commands[3]
            else
                windower.add_to_chat(200, "Rnghelper : Clearing assist.")
                assist = nil
            end
        elseif commands[2] and commands[2]:lower() == 'turn' then
            if turn then
                windower.add_to_chat(200, "Rnghelper : Disabling auto turn")
                turn = false
                cancel = false
            else
                windower.add_to_chat(200, "Rnghelper : Enabling auto turn")
            end
        elseif commands[2] and commands[2]:lower() == 'print' then
            if pending then
                windower.add_to_chat(200, pending.prefix .. pending.english .. pending.target)
            end
            for k, v in pairs(queue.data) do
                windower.add_to_chat(200, k .. v.prefix .. v.english .. v.target)
            end
        elseif commands[2] and commands[2]:lower() == 'save' then
            save_profile(commands[3])
        elseif commands[2] and commands[2]:lower() == 'load' then
            load_profile(commands[3], true)
        elseif commands[2] and commands[2]:lower() == 'clear' then
            windower.add_to_chat(200, "Rnghelper : Clearing queue")
            clear()
        elseif commands[2] and commands[2]:lower() == 'enable' then
            if enabled then
                windower.add_to_chat(200, "Rnghelper : Already enabled")
            else
                windower.add_to_chat(200, "Rnghelper : Enabling")
                enabled = true
            end
        elseif commands[2] and commands[2]:lower() == 'disable' then
            if not enabled then
                windower.add_to_chat(200, "Rnghelper : Already disabled")
            else
                windower.add_to_chat(200, "Rnghelper : Disabling")
                clear()
                enabled = false
            end
        end
        return true
    end
    return false
end)

load_profile(settings.default)
windower.raw_register_event('incoming chunk', handle_incoming_action_packet)
windower.raw_register_event('incoming chunk', handle_incoming_action_message_packet)
windower.raw_register_event('outgoing chunk', handle_outgoing_action_packet)
windower.raw_register_event('incoming chunk', monitor_target)
windower.raw_register_event('incoming chunk', acquire_pet)

------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
Format XML - Name rnghelper_settings       Speicherort:  Windower/addons/gearswap/libs
------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------

<?xml version="1.1" ?>
<settings>
    <global>
        <default>default</default>
        <profiles>
            <default>
                <cooldowns>
                    <bstpet>0</bstpet>
                    <item>1.1</item>
                    <jobability>0</jobability>
                    <magic>2.75</magic>
                    <monsterskill>2.25</monsterskill>
                    <ninjutsu>2.75</ninjutsu>
                    <pet>0</pet>
                    <range>1.15</range>
                    <song>2.75</song>
                    <weaponskill>2.45</weaponskill>
                </cooldowns>
                <mode>pummel</mode>
                <weaponskill>Coronach</weaponskill>
                <turn>true</turn>
            </default>
            <ls>
                <cooldowns>
                    <bstpet>0</bstpet>
                    <item>1.1</item>
                    <jobability>0</jobability>
                    <magic>2.75</magic>
                    <monsterskill>2.25</monsterskill>
                    <ninjutsu>2.75</ninjutsu>
                    <pet>0</pet>
                    <range>1.15</range>
                    <song>2.75</song>
                    <weaponskill>2.45</weaponskill>
                </cooldowns>
                <mode>pummel</mode>
                <weaponskill>Coronach</weaponskill>
                <turn>true</turn>
            </ls>
        </profiles>
    </global>
</settings>