GearSwap For Dummies!

-------------------------------------------------------------------------------------------------------------------
-- Initialization function that defines sets and variables to be used.
-------------------------------------------------------------------------------------------------------------------

-- IMPORTANT: Make sure to also get the Mote-Include.lua file (and its supplementary files) to go with this.

-- Initialization function for this job file.
function get_sets()
	-- Load and initialize the include file.
	include('Mote-Include.lua')
end


-- Called when this job file is unloaded (eg: job change)
function file_unload()
	if binds_on_unload then
		binds_on_unload()
	end

	send_command('unbind ^`')
	send_command('unbind !`')
	send_command('unbind ^=')
	send_command('unbind !=')
	send_command('unbind ^-')
	send_command('unbind !-')
end


-- Define sets and vars used by this job file.
function init_gear_sets()
	-- Default macro set/book
	set_macro_page(2, 5)

	-- Additional local binds
	send_command('bind ^= gs c cycle mainstep')
	send_command('bind != gs c cycle altstep')
	send_command('bind ^- gs c toggle selectsteptarget')
	send_command('bind !- gs c toggle usealtstep')
	send_command('bind ^` input /ja "Chocobo Jig" <me>')
	send_command('bind !` input /ja "Chocobo Jig II" <me>')

	determine_haste_group()


	-- Options: Override default values
	options.OffenseModes = {'Normal', 'PDT', 'PDTH', 'Acc'}
	options.DefenseModes = {'Normal', 'Evasion', 'PDT'}
	options.WeaponskillModes = {'Normal', 'Acc'}
	options.IdleModes = {'Normal'}
	options.RestingModes = {'Normal'}
	options.PhysicalDefenseModes = {'Evasion', 'PDT'}
	options.MagicalDefenseModes = {'MDT'}

	state.Defense.PhysicalMode = 'Evasion'


	options.StepModes = {'Box Step', 'Quickstep'}
	state.MainStep = 'Box Step'
	state.AltStep = 'Quickstep'
	state.CurrentStep = 'Main'
	state.UseAltStep = false
	state.SelectStepTarget = false
	state.IgnoreTargetting = false

	skillchainPending = false
end


-------------------------------------------------------------------------------------------------------------------
-- Job-specific hooks that are called to process player actions at specific points in time.
-------------------------------------------------------------------------------------------------------------------

-- Set eventArgs.handled to true if we don't want any automatic gear equipping to be done.
-- Set eventArgs.useMidcastGear to true if we want midcast gear equipped on precast.
function job_precast(spell, action, spellMap, eventArgs)
	--auto_presto(spell)
	if spell.type == 'Waltz' then
		refine_waltz(spell, action, spellMap, eventArgs)
	end
	cancel_conflicting_buffs(spell, action, spellMap, eventArgs)
end


function cancel_conflicting_buffs(spell, action, spellMap, eventArgs)
	if spell.name == 'Spectral Jig' and buffactive.sneak then
		send_command('cancel sneak')
	elseif (spell.name == 'Trance' or spell.type=='Waltz') and buffactive['saber dance'] then
		send_command('cancel saber dance')
	elseif spell.type=='Samba' and buffactive['fan dance'] then
		send_command('cancel fan dance')
	elseif spell.name:startswith('Monomi') then
		send_command('@wait 1.7;cancel sneak')
	elseif spell.name == 'Utsusemi: Ichi' then
		send_command('@wait 1.7;cancel copy image*')
	end
end


function job_post_precast(spell, action, spellMap, eventArgs)
	if spell.type:lower() == "weaponskill" then
		if skillchainPending then
			equip(sets.precast.Skillchain)
		end
	end
end


-- Return true if we handled the aftercast work.  Otherwise it will fall back
-- to the general aftercast() code in Mote-Include.
function job_aftercast(spell, action, spellMap, eventArgs)
	if not spell.interrupted then
		if spell.english == "Wild Flourish" then
			skillchainPending = true
			send_command('wait 7;gs c clear skillchainPending')
		elseif spell.type:lower() == "weaponskill" then
			skillchainPending = not skillchainPending
			send_command('wait 7;gs c clear skillchainPending')
		end
	end
end


-------------------------------------------------------------------------------------------------------------------
-- Customization hooks for idle and melee sets, after they've been automatically constructed.
-------------------------------------------------------------------------------------------------------------------

function customize_idle_set(idleSet)
	if player.hpp < 95 and not areas.Cities:contains(world.area) then
		idleSet = set_combine(idleSet, sets.ExtraRegen)
	end

	return idleSet
end


function customize_melee_set(meleeSet)
	if not state.Defense.Active then
		if buffactive['saber dance'] then
			meleeSet = set_combine(meleeSet, sets.buff['Saber Dance'])
		end
		if buffactive['climactic flourish'] then
			meleeSet = set_combine(meleeSet, sets.buff['Climactic Flourish'])
		end
	end

	return meleeSet
end

-------------------------------------------------------------------------------------------------------------------
-- General hooks for other events.
-------------------------------------------------------------------------------------------------------------------

-- Called when a player gains or loses a buff.
-- buff == buff gained or lost
-- gain == true if the buff was gained, false if it was lost.
function job_buff_change(buff,gain)
	-- If we gain or lose any haste buffs, adjust which gear set we target.
	if S{'haste','march','embrava','haste samba'}:contains(buff:lower()) then
		determine_haste_group()
		handle_equipping_gear(player.status)
	elseif buff == 'Saber Dance' or buff == 'Climactic Flourish' then
		handle_equipping_gear(player.status)
	end
end


-------------------------------------------------------------------------------------------------------------------
-- User code that supplements self-commands.
-------------------------------------------------------------------------------------------------------------------

-- Called for custom player commands.
function job_self_command(cmdParams, eventArgs)
	if cmdParams[1] == 'clear' and cmdParams[2] and cmdParams[2]:lower() == 'skillchainpending' then
		skillchainPending = false
	elseif cmdParams[1] == 'step' then
		if cmdParams[2] == 't' then
			state.IgnoreTargetting = true
		end

		local doStep = state.MainStep
		if state.UseAltStep then
			doStep = state[state.CurrentStep..'Step']
			if state.CurrentStep == 'Main' then
				state.CurrentStep = 'Alt'
			else
				state.CurrentStep = 'Main'
			end
		end

		send_command('@input /ja "'..doStep..'" <t>')
	end
end


-- Called by the default 'update' self-command.
function job_update(cmdParams, eventArgs)
	determine_haste_group()
end

-- Hooks for step mode handling.

-- Job-specific toggles.
function job_toggle(field)
	if field:lower() == 'selectsteptarget' then
		state.SelectStepTarget = not state.SelectStepTarget
		return "Select Step Target", state.SelectStepTarget
	elseif field:lower() == 'usealtstep' then
		state.UseAltStep = not state.UseAltStep
		return "Use Alt Step", state.UseAltStep
	end
end

-- Request job-specific mode tables.
-- Return the list, and the current value for the requested field.
function job_get_mode_list(field)
	if field == 'Mainstep' then
		return options.StepModes, state.MainStep
	elseif field == 'Altstep' then
		return options.StepModes, state.AltStep
	end
end

-- Set job-specific mode values.
-- Return true if we recognize and set the requested field.
function job_set_mode(field, val)
	if field == 'Mainstep' then
		state.MainStep = val
		return true
	elseif field == 'Altstep' then
		state.AltStep = val
		return true
	end
end

-- Handle auto-targetting based on local setup.
function job_auto_change_target(spell, action, spellMap, eventArgs)
	if spell.type == 'Step' then
		if state.IgnoreTargetting then
			state.IgnoreTargetting = false
			eventArgs.handled = true
		end

		eventArgs.SelectNPCTargets = state.SelectStepTarget
	end
end


-- Function to display the current relevant user state when doing an update.
-- Set eventArgs.handled to true if display was handled, and you don't want the default info shown.
function display_current_job_state(eventArgs)
	local defenseString = ''
	if state.Defense.Active then
		local defMode = state.Defense.PhysicalMode
		if state.Defense.Type == 'Magical' then
			defMode = state.Defense.MagicalMode
		end

		defenseString = 'Defense: '..state.Defense.Type..' '..defMode..', '
	end

	local steps = ''
	if state.UseAltStep then
		steps = ', ['..state.MainStep..'/'..state.AltStep..']'
	else
		steps = ', ['..state.MainStep..']'
	end

	if state.SelectStepTarget then
		steps = steps..' (Targetted)'
	end


	add_to_chat(122,'Melee: '..state.OffenseMode..'/'..state.DefenseMode..', WS: '..state.WeaponskillMode..', '..defenseString..
		'Kiting: '..on_off_names[state.Kiting]..steps)

	eventArgs.handled = true
end


-------------------------------------------------------------------------------------------------------------------
-- Utility functions specific to this job.
-------------------------------------------------------------------------------------------------------------------

function determine_haste_group()
	-- We have three groups of DW in gear: Charis body, Charis neck + DW earrings, and Patentia Sash.

	-- For high haste, we want to be able to drop one of the 10% groups (body, preferably).
	-- High haste buffs:
	-- 2x Marches + Haste
	-- 2x Marches + Haste Samba
	-- 1x March + Haste + Haste Samba
	-- Embrava + any other haste buff

	-- For max haste, we probably need to consider dropping all DW gear.
	-- Max haste buffs:
	-- Embrava + Haste/March + Haste Samba
	-- 2x March + Haste + Haste Samba

	classes.CustomMeleeGroups:clear()

	if buffactive.embrava and (buffactive.haste or buffactive.march) and buffactive['haste samba'] then
		classes.CustomMeleeGroups:append('MaxHaste')
	elseif buffactive.march == 2 and buffactive.haste and buffactive['haste samba'] then
		classes.CustomMeleeGroups:append('MaxHaste')
	elseif buffactive.embrava and (buffactive.haste or buffactive.march or buffactive['haste samba']) then
		classes.CustomMeleeGroups:append('HighHaste')
	elseif buffactive.march == 1 and buffactive.haste and buffactive['haste samba'] then
		classes.CustomMeleeGroups:append('HighHaste')
	elseif buffactive.march == 2 and (buffactive.haste or buffactive['haste samba']) then
		classes.CustomMeleeGroups:append('HighHaste')
	end
end


-- Automatically use Presto for steps when it's available and we have less than 3 finishing moves
function job_pretarget(spell, action, spellMap, eventArgs)
	if spell.type == 'Step' then
		local allRecasts = windower.ffxi.get_ability_recasts()
		local prestoCooldown = allRecasts[236]
		local under3FMs = not buffactive['Finishing Move 3'] and not buffactive['Finishing Move 4'] and not buffactive['Finishing Move 5']
		
		if player.main_job_level >= 77 and prestoCooldown < 1 and under3FMs then
			cast_delay(1.1)
			send_command('input /ja "Presto" <me>')
		end
	end
end

-------------------------------------------------------------------------------------------------------------------
-- General utility functions that can be used by any job files.  Outside the scope of what the main
-- include file deals with.
-------------------------------------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------------------------------------
-- Buff-cancelling utility functions.
-------------------------------------------------------------------------------------------------------------------


-------------------------------------------------------------------------------------------------------------------
-- Utility functions for changing target types and spells in an automatic manner.
-------------------------------------------------------------------------------------------------------------------

-- Utility function for automatically adjusting the waltz spell being used to match the HP needs.
-- Handle spell changes before attempting any precast stuff.
-- Returns two values on completion:
-- 1) bool of whether the original spell was cancelled
-- 2) bool of whether the spell was changed to something new
function refine_waltz(spell, action, spellMap, eventArgs)
	if spell.type ~= 'Waltz' then
		return
	end

	-- Don't modify anything for Healing Waltz or Divine Waltzes
	if spell.name == "Healing Waltz" or spell.name == "Divine Waltz" or spell.name == "Divine Waltz II" then
		return
	end

	local newWaltz = spell.english

	local missingHP = 0
	local targ

	-- If curing ourself, get our exact missing HP
	if spell.target.type == "SELF" then
		targ = alliance[1][1]
		missingHP = player.max_hp - player.hp
	-- If curing someone in our alliance, we can estimate their missing HP
	elseif spell.target.isallymember then
		targ = find_player_in_alliance(spell.target.name)
		local est_max_hp = targ.hp / (targ.hpp/100)
		missingHP = math.floor(est_max_hp - targ.hp)
	end

	-- If we can estimate missing HP, we can adjust the preferred tier used.
	if targ then
		if player.main_job == 'DNC' then
			if missingHP < 40 then
				-- not worth curing
				add_to_chat(122,'Full HP!')
				eventArgs.cancel = true
				return
			elseif missingHP < 200 then
				newWaltz = 'Curing Waltz'
			elseif missingHP < 600 then
				newWaltz = 'Curing Waltz II'
			else
				newWaltz = 'Curing Waltz III'
			end
		elseif player.sub_job == 'DNC' then
			if missingHP < 150 then
				newWaltz = 'Curing Waltz'
			elseif missingHP < 300 then
				newWaltz = 'Curing Waltz II'
			else
				newWaltz = 'Curing Waltz III'
			end
		else
			return
		end
	end

	local waltzTPCost = {['Curing Waltz'] = 20,['Curing Waltz II'] = 35,['Curing Waltz III'] = 50,['Curing Waltz IV'] = 65,['Curing Waltz V'] = 80}
	local tpCost = waltzTPCost[newWaltz]
	local downgrade

	-- Downgrade the spell to what we can afford
	if player.tp < tpCost and not buffactive.trance then
		--[[ Costs:
			Curing Waltz:     20 TP
			Curing Waltz II:  35 TP
			Curing Waltz III: 50 TP
			Curing Waltz IV:  65 TP
			Curing Waltz V:   80 TP
			Divine Waltz:     40 TP
			Divine Waltz II:  80 TP
		--]]

		if player.tp < 20 then
			add_to_chat(122, 'Insufficient TP ['..tostring(player.tp)..']. Cancelling.')
			eventArgs.cancel = true
			return
		elseif player.tp < 35 then
			newWaltz = 'Curing Waltz'
		elseif player.tp < 50 then
			newWaltz = 'Curing Waltz II'
		elseif player.tp < 65 then
			newWaltz = 'Curing Waltz III'
		elseif player.tp < 80 then
			newWaltz = 'Curing Waltz IV'
		end

		downgrade = 'Insufficient TP ['..tostring(player.tp)..']. Downgrading to '..newWaltz..'.'
	end


	if newWaltz ~= spell.english then
		send_command('@input /ja "'..newWaltz..'" '..tostring(spell.target.raw))
		if downgrade then
			add_to_chat(122, downgrade)
		end
		eventArgs.cancel = true
		return
	end

	if missingHP > 0 then
		add_to_chat(122,'Trying to cure '..tostring(missingHP)..' HP using '..newWaltz..'.')
	end
end


-- Function to allow for automatic adjustment of the spell target type based on preferences.
function auto_change_target(spell, action, spellMap)
	-- Do not modify target for spells where we get <lastst> or <me>.
	if spell.target.raw == ('<lastst>') or spell.target.raw == ('<me>') then
		return
	end

	-- init a new eventArgs with current values
	local eventArgs = {handled = false, PCTargetMode = state.PCTargetMode, SelectNPCTargets = state.SelectNPCTargets}

	-- Allow the job to do custom handling, or override the default values.
	-- They can completely handle it, or set one of the secondary eventArgs vars to selectively
	-- override the default state vars.
	if job_auto_change_target then
		job_auto_change_target(spell, action, spellMap, eventArgs)
	end

	-- If the job handled it, we're done.
	if eventArgs.handled then
		return
	end

	local pcTargetMode = eventArgs.PCTargetMode
	local selectNPCTargets = eventArgs.SelectNPCTargets

	local canUseOnPlayer = spell.validtarget and 
		(spell.validtarget.Self or spell.validtarget.Player or spell.validtarget.Party or spell.validtarget.Ally or spell.validtarget.NPC)

	local newTarget

	-- For spells that we can cast on players:
	if canUseOnPlayer and pcTargetMode ~= 'default' then
		if pcTargetMode == 'stal' then
			-- Use <stal> if possible, otherwise fall back to <stpt>.
			if spell.validtarget.Ally then
				newTarget = '<stal>'
			elseif spell.validtarget.Party then
				newTarget = '<stpt>'
			end
		elseif pcTargetMode == 'stpt' then
			-- Even ally-possible spells are limited to the current party.
			if spell.validtarget.Ally or spell.validtarget.Party then
				newTarget = '<stpt>'
			end
		elseif pcTargetMode == 'stpc' then
			-- If it's anything other than a self-only spell, can change to <stpc>.
			if spell.validtarget.Player or spell.validtarget.Party or spell.validtarget.Ally or spell.validtarget.NPC then
				newTarget = '<stpc>'
			end
		end
	-- For spells that can be used on enemies:
	elseif spell.validtarget and spell.validtarget.Enemy and selectNPCTargets then
		-- Note: this means macros should be written for <t>, and it will change to <stnpc>
		-- if the flag is set.  It won't change <stnpc> back to <t>.
		newTarget = '<stnpc>'
	end

	-- If a new target was selected and is different from the original, call the change function.
	if newTarget and newTarget ~= spell.target.raw then
		change_target(newTarget)
	end
end


-------------------------------------------------------------------------------------------------------------------
-- Environment utility functions.
-------------------------------------------------------------------------------------------------------------------

-- Function to get the current weather intensity: 0 for none, 1 for single weather, 2 for double weather.
function get_weather_intensity()
	if world.weather_id <= 3 then
		return 0
	else
		return (world.weather_id % 2) + 1
	end
end


function is_trust_party()
	-- Check if we're solo
	if party.count == 1 then
		return false
	end

	-- Can call a max of 3 Trust NPCs, so parties larger than that are out.
	if party.count > 4 then
		return false
	end

	-- If we're in an alliance, can't be a Trust party.
	if alliance[2].count > 0 or alliance[3].count > 0 then
		return false
	end

	-- Check that, for each party position aside from our own, the party
	-- member has one of the Trust NPC names, and that those party members
	-- are flagged is_npc.
	for i = 2,4 do
		if party[i] then
			if not npcs.Trust:contains(party[i].name) then
				return false
			end
			if party[i].mob and party[i].mob.is_npc == false then
				return false
			end
		end
	end

	return true
end


-------------------------------------------------------------------------------------------------------------------
-- Gear utility functions.
-------------------------------------------------------------------------------------------------------------------

-- Pick an item to use based on required elemental properties.
-- Cycles through the list of all elements until it matches one of the
-- provided elements to search, and checks whether an appropriate item
-- of that type exists in inventory.  If so, uses that.
-- It may optionally provide a list of valid elements, rather than
-- searching all possible elements.
-- Returns the item var if it found a match and the item was in inventory.
function select_elemental_item(itemvar, itemtype, elements_to_search, valid_elements)
	local elements_list = valid_elements or elements.list

	for _,element in ipairs(elements_list) do
		if elements_to_search:contains(element) and player.inventory[gear_map[itemtype][element]] then
			itemvar.name = gear_map[itemtype][element]
			return itemvar
		end
	end
end


-- Function to get an appropriate gorget and belt for the current weaponskill.
function set_weaponskill_gorget_belt(spell)
	if spell.type ~= 'WeaponSkill' then
		return
	end

	-- Get the union of all the skillchain elements for the weaponskill
	local weaponskill_elements = S{}:
		union(skillchain_elements[spell.wsA]):
		union(skillchain_elements[spell.wsB]):
		union(skillchain_elements[spell.wsC])

	-- Hook to the default gear vars, if available.
	local gorget = gear.ElementalGorget or {name=""}
	gorget.name = gear.default.weaponskill_neck or ""
	local belt = gear.ElementalBelt or {name=""}
	belt.name = gear.default.weaponskill_waist or ""

	select_elemental_item(gorget, 'Gorget', weaponskill_elements)
	select_elemental_item(belt, 'Belt', weaponskill_elements)

	return gorget, belt
end


-- Function to get an appropriate obi/cape/ring for the current spell.
function set_spell_obi_cape_ring(spell)
	if spell.element == 'None' then
		return
	end

	local world_elements = S{}
	world_elements:add(world.weather_element)
	world_elements:add(world.day_element)

	local obi = gear.ElementalObi or {name=""}
	obi.name = gear.default.obi_waist or ""
	local cape = gear.ElementalCape or {name=""}
	cape.name = gear.default.obi_back or ""
	local ring = gear.ElementalRing or {name=""}
	ring.name = gear.default.obi_ring or ""

	local got_obi = select_elemental_item(obi, 'Obi', S{spell.element}, world_elements)

	if got_obi then
		if player.inventory['Twilight Cape'] then
			cape.name = "Twilight Cape"
		end
		if player.inventory['Zodiac Ring'] and spell.english ~= 'Impact' and
			not S{'DivineMagic','DarkMagic','HealingMagic'}:contains(spell.skill) then
			ring.name = "Zodiac Ring"
		end
	end

	return obi, cape, ring
end


-- Function to get an appropriate gorget and belt for the current weaponskill.
function set_fastcast_staff(spell)
	if spell.action_type ~= 'Magic' then
		return
	end

	local staff = gear.FastcastStaff or {name=""}

	if gear_map['FastcastStaff'][spell.element] and player.inventory[gear_map['FastcastStaff'][spell.element]] then
		staff.name = gear_map['FastcastStaff'][spell.element]
	else
		staff.name = gear.default.fastcast_staff or ""
	end

	return staff
end


-- Function to get an appropriate gorget and belt for the current weaponskill.
function set_recast_staff(spell)
	if spell.action_type ~= 'Magic' then
		return
	end

	local staff = gear.RecastStaff or {name=""}

	if gear_map['RecastStaff'][spell.element] and player.inventory[gear_map['RecastStaff'][spell.element]] then
		staff.name = gear_map['RecastStaff'][spell.element]
	else
		staff.name = gear.default.recast_staff or ""
	end

	return staff
end

-------------------------------------------------------------------------------------------------------------------
-- Function to easily change to a given macro set or book.  Book value is optional.
-------------------------------------------------------------------------------------------------------------------

function set_macro_page(set,book)
	if not tonumber(set) then
		add_to_chat(123,'Error setting macro page: Set is not a valid number ('..tostring(set)..').')
		return
	end
	if set < 1 or set > 10 then
		add_to_chat(123,'Error setting macro page: Macro set ('..tostring(set)..') must be between 1 and 10.')
		return
	end

	if book then
		if not tonumber(book) then
			add_to_chat(123,'Error setting macro page: book is not a valid number ('..tostring(book)..').')
			return
		end
		if book < 1 or book > 20 then
			add_to_chat(123,'Error setting macro page: Macro book ('..tostring(book)..') must be between 1 and 20.')
			return
		end
		send_command('@input /macro book '..tostring(book)..';wait .1;input /macro set '..tostring(set))
	else
		send_command('@input /macro set '..tostring(set))
	end
end


-------------------------------------------------------------------------------------------------------------------
-- Utility functions for including local user files.
-------------------------------------------------------------------------------------------------------------------

-- Attempt to load user gear files in place of default gear sets.
-- Return true if one exists and was loaded.
function load_user_gear(job)
	if not job then return false end

	-- filename format example for user-local files: whm_gear.lua, or playername_whm_gear.lua
	local filenames = {player.name..'_'..job..'_gear.lua', job..'_gear.lua'}
	return optional_include(filenames)
end

-- Attempt to include user-globals.  Return true if it exists and was loaded.
function load_user_globals()
	local filenames = {'user-globals.lua'}
	return optional_include(filenames)
end

-- Optional version of include().  If file does not exist, does not
-- attempt to load, and does not throw an error.
-- filenames takes an array of possible file names to include and checks
-- each one.
function optional_include(filenames)
	for _,v in pairs(filenames) do
		local path = gearswap.pathsearch({v})
		if path then
			include(v)
			return true
		end
	end
end

-------------------------------------------------------------------------------------------------------------------
-- Utility functions for vars or other data manipulation.
-------------------------------------------------------------------------------------------------------------------

-- Attempt to locate a specified name within the current alliance.
function find_player_in_alliance(name)
	for i,v in ipairs(alliance) do
		for k,p in ipairs(v) do
			if p.name == name then
				return p
			end
		end
	end
end

-- Invert a table such that the keys are values and the values are keys.
-- Use this to look up the index value of a given entry.
function invert_table(t)
	if t == nil then error('Attempting to invert table, received nil.', 2) end

	local i={}
	for k,v in pairs(t) do 
		i[v] = k
	end
	return i
end

-- Gets sub-tables based on baseSet from the string str that may be in dot form
-- (eg: baseSet=sets, str='precast.FC', this returns sets.precast.FC).
function get_expanded_set(baseSet, str)
	local cur = baseSet
	for i in str:gmatch("[^.]+") do
		cur = cur[i]
	end

	return cur
end