550 lines
21 KiB
Lua
550 lines
21 KiB
Lua
setfenv(1, VoiceOver)
|
|
|
|
|
|
local CURRENT_MODULE_VERSION = 1
|
|
local FORCE_ENABLE_DISABLED_MODULES = true
|
|
local LOAD_ALL_MODULES = true
|
|
|
|
---@class DataModuleMetadata
|
|
---@field AddonName string Addon name
|
|
---@field LoadOnDemand boolean Whether the module can be dynamically loaded (TOC ##LoadOnDemand)
|
|
---@field ModuleVersion number Module's data format version (TOC ##X-VoiceOver-DataModule-Version, must be CURRENT_MODULE_VERSION to be loaded)
|
|
---@field ModulePriority number Module's priority (TOC ##X-VoiceOver-DataModule-Priority, larger number = higher priority)
|
|
---@field ContentVersion? string Module's content version (TOC ##Version)
|
|
---@field Title string Module's title (TOC ##Title or addon name if missing)
|
|
---@field Maps number[] Map IDs in which the module should load (TOC ##X-VoiceOver-DataModule-Maps)
|
|
|
|
---@class DataModule
|
|
---@field METADATA DataModuleMetadata
|
|
---@field GetSoundPath fun(self: DataModule, fileName: string, event: SoundEvent): string Function implemented in the module that returns the sound path for the desired voiceover
|
|
---@field GossipLookupByNPCID table<number, table<string, string>> Maps Creature ID and fuzzy-searchable gossip text to gossip text hash
|
|
---@field GossipLookupByNPCName table<string, table<string, string>> Maps Creature name and fuzzy-searchable gossip text to gossip text hash
|
|
---@field GossipLookupByObjectID table<number, table<string, string>> Maps GameObject ID and fuzzy-searchable gossip text to gossip text hash
|
|
---@field GossipLookupByObjectName table<string, table<string, string>> Maps GameObject name and fuzzy-searchable gossip text to gossip text hash
|
|
---@field QuestIDLookup table<QuestIDLookupSource, table<string, number|table<string, number|table<string, number>>>> Maps quest title to quest ID or (if there is ambiguity) maps quest title and quest giver name to quest ID or (if there is ambiguity) maps quest title and quest giver name and fuzzy-searchable quest text to quest ID
|
|
---@field NPCIDLookupByQuestID table<number, number> Maps Quest ID to quest giver Creature ID
|
|
---@field ObjectIDLookupByQuestID table<number, number> Maps Quest ID to quest giver GameObject ID
|
|
---@field ItemIDLookupByQuestID table<number, number> Maps Quest ID to quest giver Item ID
|
|
---@field NPCNameLookupByNPCID table<number, string> Maps Creature ID to Creature name
|
|
---@field ObjectNameLookupByObjectID table<number, string> Maps GameObject ID to GameObject name
|
|
---@field ItemNameLookupByItemID table<number, string> Maps Item ID to Item name
|
|
---@field SoundLengthLookupByFileName table<string, number> Maps sound filenames to their duration in seconds
|
|
|
|
---@class AvailableDataModule
|
|
---@field AddonName string Addon name
|
|
---@field Title string Module's title (TOC ##Title)
|
|
---@field ContentVersion string Module's content version (TOC ##Version)
|
|
---@field RelevantAboveVersion? number Interface number above which (inclusive) it makes sense to show this module as available to download or update
|
|
---@field RelevantBelowVersion? number Interface number below which (exclusive) it makes sense to show this module as available to download or update
|
|
---@field URL string URL where the module can be downloaded
|
|
|
|
DataModules =
|
|
{
|
|
--- Store the modules present in Interface\AddOns folder, whether they're loaded or not
|
|
---@type table<string, DataModuleMetadata>
|
|
presentModules = {},
|
|
|
|
--- Stores present modules with a consistent ordering (which key-value hashmaps don't provide) to avoid bugs that can only be reproduced randomly
|
|
---@type DataModuleMetadata[]
|
|
presentModulesOrdered = {},
|
|
|
|
--- Stores the modules that were already loaded and registered
|
|
---@type table<string, DataModule>
|
|
registeredModules = {},
|
|
|
|
--- Stores registered modules with a consistent ordering (which key-value hashmaps don't provide) to avoid bugs that can only be reproduced randomly
|
|
---@type DataModule[]
|
|
registeredModulesOrdered = {}, -- To have a consistent ordering of modules (which key-value hashmaps don't provide) to avoid bugs that can only be reproduced randomly
|
|
|
|
--- Stores modules known to exist to present the player with information on how to download or update them
|
|
---@type AvailableDataModule[]
|
|
availableModules = {
|
|
{
|
|
AddonName = "AI_VoiceOverData_Vanilla",
|
|
Title = "VoiceOver Data - Vanilla",
|
|
ContentVersion = "0.1",
|
|
RelevantAboveVersion = 0,
|
|
URL = "https://www.curseforge.com/wow/addons/voiceover-sounds-vanilla",
|
|
},
|
|
{
|
|
AddonName = "AI_VoiceOverData_VanillaExtra",
|
|
Title = "VoiceOver Data - Vanilla Extra",
|
|
ContentVersion = "1.3",
|
|
RelevantAboveVersion = 0,
|
|
URL = "https://www.curseforge.com/wow/addons/voiceover-vanillaextra-audio",
|
|
},
|
|
{
|
|
AddonName = "AI_VoiceOverData_TBC",
|
|
Title = "VoiceOver Data - TBC",
|
|
ContentVersion = "1.2",
|
|
RelevantAboveVersion = 0,
|
|
URL = "https://www.curseforge.com/wow/addons/voiceover-tbc-audio",
|
|
},
|
|
{
|
|
AddonName = "AI_VoiceOverData_WoTLK",
|
|
Title = "VoiceOver Data - WoTLK",
|
|
ContentVersion = "1.0",
|
|
RelevantAboveVersion = 0,
|
|
URL = "https://www.curseforge.com/wow/addons/voiceover-wotlk-audio",
|
|
},
|
|
},
|
|
}
|
|
|
|
---@param a DataModule|DataModuleMetadata
|
|
---@param b DataModule|DataModuleMetadata
|
|
local function SortModules(a, b)
|
|
a = a.METADATA or a
|
|
b = b.METADATA or b
|
|
if a.ModulePriority ~= b.ModulePriority then
|
|
return a.ModulePriority > b.ModulePriority
|
|
end
|
|
return a.AddonName < b.AddonName
|
|
end
|
|
|
|
---@param name string Addon name
|
|
---@param module DataModule Module data table
|
|
function DataModules:Register(name, module)
|
|
assert(not self.registeredModules[name], format([[Module "%s" already registered]], name))
|
|
|
|
local metadata = assert(self.presentModules[name],
|
|
format([[Module "%s" attempted to register but wasn't detected during addon enumeration]], name))
|
|
local moduleVersion = assert(tonumber(GetAddOnMetadata(name, "X-VoiceOver-DataModule-Version")),
|
|
format([[Module "%s" is missing data format version]], name))
|
|
|
|
-- Ideally if module format would ever change - there should be fallbacks in place to handle outdated formats
|
|
assert(moduleVersion == CURRENT_MODULE_VERSION,
|
|
format([[Module "%s" contains outdated data format (version %d, expected %d)]], name, moduleVersion,
|
|
CURRENT_MODULE_VERSION))
|
|
|
|
module.METADATA = metadata
|
|
|
|
self.registeredModules[name] = module
|
|
table.insert(self.registeredModulesOrdered, module)
|
|
|
|
-- Order the modules by priority (higher first) then by name (case-sensitive alphabetical)
|
|
-- Modules with higher priority will be iterated through first, so one can create a module with "overrides" for data in other modules by simply giving it a higher priority
|
|
table.sort(self.registeredModulesOrdered, SortModules)
|
|
end
|
|
|
|
function DataModules:HasRegisteredModules()
|
|
return next(self.registeredModules) ~= nil
|
|
end
|
|
|
|
function DataModules:GetModule(name)
|
|
return self.registeredModules[name]
|
|
end
|
|
|
|
function DataModules:GetModules()
|
|
return ipairs(self.registeredModulesOrdered)
|
|
end
|
|
|
|
function DataModules:GetPresentModule(name)
|
|
return self.presentModules[name]
|
|
end
|
|
|
|
function DataModules:GetPresentModules()
|
|
return ipairs(self.presentModulesOrdered)
|
|
end
|
|
|
|
function DataModules:GetAvailableModules()
|
|
return ipairs(self.availableModules)
|
|
end
|
|
|
|
function DataModules:EnumerateAddons()
|
|
local playerName = UnitName("player")
|
|
for i = 1, GetNumAddOns() do
|
|
local moduleVersion = tonumber(GetAddOnMetadata(i, "X-VoiceOver-DataModule-Version"))
|
|
if moduleVersion and (FORCE_ENABLE_DISABLED_MODULES or GetAddOnEnableState(playerName, i) ~= 0) then
|
|
local name = GetAddOnInfo(i)
|
|
local mapsString = GetAddOnMetadata(i, "X-VoiceOver-DataModule-Maps")
|
|
local maps = {}
|
|
if mapsString then
|
|
for _, mapString in ipairs({ strsplit(",", mapsString) }) do
|
|
local map = tonumber(mapString)
|
|
if map then
|
|
maps[map] = true
|
|
end
|
|
end
|
|
end
|
|
---@type DataModuleMetadata
|
|
local module =
|
|
{
|
|
AddonName = name,
|
|
LoadOnDemand = IsAddOnLoadOnDemand(name),
|
|
ModuleVersion = moduleVersion,
|
|
ModulePriority = tonumber(GetAddOnMetadata(name, "X-VoiceOver-DataModule-Priority")) or 0,
|
|
ContentVersion = GetAddOnMetadata(name, "Version"),
|
|
Title = GetAddOnMetadata(name, "Title") or name,
|
|
Maps = maps,
|
|
}
|
|
self.presentModules[name] = module
|
|
table.insert(self.presentModulesOrdered, module)
|
|
|
|
-- Maybe in the future we can load modules based on the map the player is in (select(8, GetInstanceInfo())), but for now - just load everything
|
|
if LOAD_ALL_MODULES and IsAddOnLoadOnDemand(name) then
|
|
DataModules:LoadModule(module)
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(self.presentModulesOrdered, SortModules)
|
|
for order, module in self:GetPresentModules() do
|
|
Options:AddDataModule(module, order)
|
|
end
|
|
|
|
for order, module in self:GetAvailableModules() do
|
|
local min = module.RelevantAboveVersion
|
|
local max = module.RelevantBelowVersion
|
|
if (not min or Version.Interface >= min) and (not max or Version.Interface < max) then
|
|
local present = self.presentModules[module.AddonName]
|
|
local update = present and present.ContentVersion ~= module.ContentVersion
|
|
if not present or update then
|
|
Options:AddAvailableDataModule(module, order, update)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- We deliberately use a high ##Interface version in TOC to ensure that all clients will load it.
|
|
-- Otherwise pre-classic-rerelease clients will refuse to load addons with version < 20000.
|
|
-- Here we temporarily enable "Load out of date AddOns" to load the module, and restore the user's setting afterwards.
|
|
-- These cvars can be nil, so have to store the fact of them being changed in a separate variable.
|
|
local prev_checkAddonVersion, changed_checkAddonVersion
|
|
local prev_lastAddonVersion, changed_lastAddonVersion -- Added in 5.x
|
|
local addonWasDisabled = {}
|
|
local function EnableOutOfDate(addon)
|
|
if not changed_checkAddonVersion then
|
|
prev_checkAddonVersion = GetCVar("checkAddonVersion")
|
|
SetCVar("checkAddonVersion", 0)
|
|
changed_checkAddonVersion = true
|
|
end
|
|
if not changed_lastAddonVersion and Version:IsRetailOrAboveLegacyVersion(50000) then
|
|
prev_lastAddonVersion = GetCVar("lastAddonVersion")
|
|
SetCVar("lastAddonVersion", Version.Interface)
|
|
changed_lastAddonVersion = true
|
|
end
|
|
|
|
addonWasDisabled[addon] = GetAddOnEnableState(UnitName("player"), addon) == 0
|
|
if FORCE_ENABLE_DISABLED_MODULES and addonWasDisabled[addon] then
|
|
EnableAddOn(addon)
|
|
end
|
|
end
|
|
local function RestoreOutOfDate(addon)
|
|
if changed_checkAddonVersion then
|
|
SetCVar("checkAddonVersion", prev_checkAddonVersion)
|
|
changed_checkAddonVersion = nil
|
|
end
|
|
if changed_lastAddonVersion and Version:IsRetailOrAboveLegacyVersion(50000) then
|
|
SetCVar("lastAddonVersion", prev_lastAddonVersion)
|
|
changed_lastAddonVersion = nil
|
|
end
|
|
|
|
if FORCE_ENABLE_DISABLED_MODULES and addonWasDisabled[addon] then
|
|
DisableAddOn(addon)
|
|
end
|
|
addonWasDisabled[addon] = nil
|
|
end
|
|
|
|
---@param module DataModuleMetadata
|
|
function DataModules:LoadModule(module)
|
|
if not module.LoadOnDemand or self:GetModule(module.AddonName) or IsAddOnLoaded(module.AddonName) then
|
|
return false
|
|
end
|
|
|
|
EnableOutOfDate(module.AddonName)
|
|
local loaded, reason = LoadAddOn(module.AddonName)
|
|
RestoreOutOfDate(module.AddonName)
|
|
return loaded, reason
|
|
end
|
|
|
|
function DataModules:GetModuleAddOnInfo(module)
|
|
EnableOutOfDate(module.AddonName)
|
|
local name, title, notes, loadable, reason = GetAddOnInfo(module.AddonName)
|
|
RestoreOutOfDate(module.AddonName)
|
|
return name, title, notes, loadable, reason
|
|
end
|
|
|
|
local function replaceDoubleQuotes(text)
|
|
return string.gsub(text, '"', "'")
|
|
end
|
|
|
|
---@param soundData SoundData
|
|
---@return string|nil hash
|
|
function DataModules:GetNPCGossipTextHash(soundData)
|
|
local table, npc
|
|
if soundData.unitGUID then
|
|
local type = Utils:GetGUIDType(soundData.unitGUID)
|
|
if Enums.GUID:IsCreature(type) then
|
|
table = "GossipLookupByNPCID"
|
|
elseif type == Enums.GUID.GameObject then
|
|
table = "GossipLookupByObjectID"
|
|
else
|
|
return
|
|
end
|
|
npc = Utils:GetIDFromGUID(soundData.unitGUID)
|
|
else
|
|
table = soundData.unitIsObjectOrItem and "GossipLookupByObjectName" or "GossipLookupByNPCName"
|
|
npc = replaceDoubleQuotes(soundData.name)
|
|
end
|
|
local text = soundData.text
|
|
|
|
local text_entries = {}
|
|
|
|
for _, module in self:GetModules() do
|
|
local data = module[table]
|
|
if data then
|
|
local npc_gossip_table = data[npc]
|
|
if npc_gossip_table then
|
|
for text, hash in pairs(npc_gossip_table) do
|
|
text_entries[text] = text_entries[text] or
|
|
hash -- Respect module priority, don't overwrite the entry if there is already one
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local best_result = FuzzySearchBestKeys(text, text_entries)
|
|
return best_result and best_result.value
|
|
end
|
|
|
|
local function getFirstNWords(text, n)
|
|
local firstNWords = {}
|
|
local count = 0
|
|
|
|
for word in string.gmatch(text, "%S+") do
|
|
count = count + 1
|
|
table.insert(firstNWords, word)
|
|
if count >= n then
|
|
break
|
|
end
|
|
end
|
|
|
|
return table.concat(firstNWords, " ")
|
|
end
|
|
|
|
local function getLastNWords(text, n)
|
|
local lastNWords = {}
|
|
local count = 0
|
|
|
|
for word in string.gmatch(text, "%S+") do
|
|
table.insert(lastNWords, word)
|
|
count = count + 1
|
|
end
|
|
|
|
local startIndex = math.max(1, count - n + 1)
|
|
local endIndex = count
|
|
|
|
return table.concat(lastNWords, " ", startIndex, endIndex)
|
|
end
|
|
|
|
---@alias QuestIDLookupSource "accept"|"progress"|"complete"
|
|
|
|
---@param source QuestIDLookupSource
|
|
---@param title string
|
|
---@param npcName string
|
|
---@param text string
|
|
---@return number questID
|
|
function DataModules:GetQuestID(source, title, npcName, text)
|
|
local cleanedTitle = replaceDoubleQuotes(title)
|
|
local cleanedNPCName = replaceDoubleQuotes(npcName)
|
|
local cleanedText = replaceDoubleQuotes(getFirstNWords(text, 20)) ..
|
|
" " .. replaceDoubleQuotes(getLastNWords(text, 20))
|
|
local text_entries = {}
|
|
|
|
for _, module in self:GetModules() do
|
|
local data = module.QuestIDLookup
|
|
if data then
|
|
local titleLookup = data[source][cleanedTitle]
|
|
if titleLookup then
|
|
if type(titleLookup) == "number" then
|
|
return titleLookup
|
|
else
|
|
-- else titleLookup is a table and we need to search it further
|
|
local npcLookup = titleLookup[cleanedNPCName]
|
|
if npcLookup then
|
|
if type(npcLookup) == "number" then
|
|
return npcLookup
|
|
else
|
|
for text, ID in pairs(npcLookup) do
|
|
text_entries[text] = text_entries[text] or
|
|
ID -- Respect module priority, don't overwrite the entry if there is already one
|
|
end
|
|
-- MOVE THE SEARCH HERE
|
|
local best_result = FuzzySearchBestKeys(cleanedText, text_entries)
|
|
if best_result then
|
|
return best_result.value -- This exits the WHOLE function immediately
|
|
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local best_result = FuzzySearchBestKeys(cleanedText, text_entries)
|
|
return best_result and best_result.value
|
|
end
|
|
|
|
---@param questID number
|
|
---@return GUID|nil type `Enums.GUID` type of the quest giver
|
|
---@return number|nil id ID of the quest giver
|
|
function DataModules:GetQuestLogQuestGiverTypeAndID(questID)
|
|
for _, module in self:GetModules() do
|
|
local data = module.NPCIDLookupByQuestID
|
|
if data then
|
|
local npcID = data[questID]
|
|
if npcID then
|
|
return Enums.GUID.Creature, npcID
|
|
end
|
|
end
|
|
|
|
data = module.ObjectIDLookupByQuestID
|
|
if data then
|
|
local objectID = data[questID]
|
|
if objectID then
|
|
return Enums.GUID.GameObject, objectID
|
|
end
|
|
end
|
|
|
|
data = module.ItemIDLookupByQuestID
|
|
if data then
|
|
local itemID = data[questID]
|
|
if itemID then
|
|
return Enums.GUID.Item, itemID
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---@param type GUID `Enums.GUID` type of the desired object
|
|
---@param id number ID of the desired object
|
|
---@return string|nil name
|
|
function DataModules:GetObjectName(type, id)
|
|
local table
|
|
if Enums.GUID:IsCreature(type) then
|
|
table = "NPCNameLookupByNPCID"
|
|
elseif type == Enums.GUID.GameObject then
|
|
table = "ObjectNameLookupByObjectID"
|
|
elseif type == Enums.GUID.Item then
|
|
table = "ItemNameLookupByItemID"
|
|
else
|
|
return
|
|
end
|
|
|
|
for _, module in self:GetModules() do
|
|
local data = module[table]
|
|
if data then
|
|
local npcName = data[id]
|
|
if npcName then
|
|
return npcName
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---@type table<SoundEvent, fun(soundData: SoundData): string|nil>
|
|
local getFileNameForEvent =
|
|
{
|
|
[Enums.SoundEvent.QuestAccept] = function(soundData) return format("%d-%s", soundData.questID, "accept") end,
|
|
[Enums.SoundEvent.QuestProgress] = function(soundData) return format("%d-%s", soundData.questID, "progress") end,
|
|
[Enums.SoundEvent.QuestComplete] = function(soundData) return format("%d-%s", soundData.questID, "complete") end,
|
|
[Enums.SoundEvent.QuestGreeting] = function(soundData) return DataModules:GetNPCGossipTextHash(soundData) end,
|
|
[Enums.SoundEvent.Gossip] = function(soundData) return DataModules:GetNPCGossipTextHash(soundData) end,
|
|
}
|
|
setmetatable(getFileNameForEvent,
|
|
{
|
|
__index = function(self, event)
|
|
error(format([[Unhandled VoiceOver sound event %d "%s"]], event,
|
|
Enums.SoundEvent:GetName(event) or "???"))
|
|
end
|
|
})
|
|
|
|
---@param soundData SoundData
|
|
---@return boolean found Whether the sound is found and can be played
|
|
function DataModules:PrepareSound(soundData)
|
|
soundData.fileName = getFileNameForEvent[soundData.event](soundData)
|
|
if soundData.fileName == nil then
|
|
return false
|
|
end
|
|
|
|
for _, module in self:GetModules() do
|
|
local data = module.SoundLengthLookupByFileName
|
|
if data then
|
|
local playerGenderedFileName = DataModules:AddPlayerGenderToFilename(soundData.fileName)
|
|
local length = data[playerGenderedFileName]
|
|
if length then
|
|
soundData.fileName = playerGenderedFileName
|
|
else
|
|
length = data[soundData.fileName]
|
|
end
|
|
if length then
|
|
soundData.filePath = format([[Interface\AddOns\%s\%s]], module.METADATA.AddonName,
|
|
module.GetSoundPath and module:GetSoundPath(soundData.fileName, soundData.event) or
|
|
soundData.fileName)
|
|
soundData.length = length
|
|
soundData.module = module
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function DataModules:AddPlayerGenderToFilename(fileName)
|
|
local playerGender = UnitSex("player")
|
|
|
|
if playerGender == 2 then -- male
|
|
return "m-" .. fileName
|
|
elseif playerGender == 3 then -- female
|
|
return "f-" .. fileName
|
|
else -- unknown or error
|
|
return fileName
|
|
end
|
|
end
|
|
|
|
-- Normalize a title: trims, removes quotes, lowercases
|
|
local function normalizeTitle(s)
|
|
if not s then return "" end
|
|
local trimmed = string.match(s, '^%s*(.-)%s*$') -- trim whitespace
|
|
trimmed = string.gsub(trimmed, '["\']', '') -- remove single and double quotes
|
|
trimmed = string.gsub(trimmed, '[\\r\\n]', '') -- remove any newlines
|
|
return string.lower(trimmed)
|
|
end
|
|
|
|
local function titlesMatch(a, b)
|
|
return normalizeTitle(a) == normalizeTitle(b)
|
|
end
|
|
|
|
function DataModules:GetQuestIDByTitle(title)
|
|
local normTitle = normalizeTitle(title)
|
|
|
|
for _, module in self:GetModules() do
|
|
local data = module.QuestIDLookup
|
|
if data then
|
|
for _, tableName in ipairs({"accept", "complete"}) do
|
|
local tbl = data[tableName]
|
|
if tbl then
|
|
for key, val in pairs(tbl) do
|
|
-- handle nested tables automatically
|
|
if type(val) == "number" then
|
|
if titlesMatch(key, normTitle) then
|
|
return val
|
|
end
|
|
elseif type(val) == "table" then
|
|
for nestedKey, nestedID in pairs(val) do
|
|
if titlesMatch(nestedKey, normTitle) then
|
|
return nestedID
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return nil
|
|
end
|