You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1092 lines
50 KiB
1092 lines
50 KiB
|
|
--todo: need to fix this file after pre-patch
|
|
|
|
local Details = _G.Details
|
|
local DF = _G.DetailsFramework
|
|
local Loc = _G.LibStub("AceLocale-3.0"):GetLocale("Details")
|
|
local _
|
|
|
|
--prefix used on sync statistics
|
|
local CONST_GUILD_SYNC = "GS"
|
|
|
|
function Details:InitializeRaidHistoryWindow()
|
|
local DetailsRaidHistoryWindow = CreateFrame("frame", "DetailsRaidHistoryWindow", UIParent,"BackdropTemplate")
|
|
DetailsRaidHistoryWindow.Frame = DetailsRaidHistoryWindow
|
|
DetailsRaidHistoryWindow.__name = Loc ["STRING_STATISTICS"]
|
|
DetailsRaidHistoryWindow.real_name = "DETAILS_STATISTICS"
|
|
DetailsRaidHistoryWindow.__icon = [[Interface\AddOns\Details\images\icons]]
|
|
DetailsRaidHistoryWindow.__iconcoords = {278/512, 314/512, 43/512, 76/512}
|
|
DetailsRaidHistoryWindow.__iconcolor = "DETAILS_STATISTICS_ICON"
|
|
DetailsPluginContainerWindow.EmbedPlugin (DetailsRaidHistoryWindow, DetailsRaidHistoryWindow, true)
|
|
|
|
function DetailsRaidHistoryWindow.RefreshWindow()
|
|
Details:OpenRaidHistoryWindow()
|
|
C_Timer.After(1, function()
|
|
Details:OpenRaidHistoryWindow()
|
|
end)
|
|
end
|
|
end
|
|
|
|
function Details:OpenRaidHistoryWindow(raidName, bossEncounterId, difficultyId, playerRole, guildName, playerBase, playerName, historyType)
|
|
if (not DetailsRaidHistoryWindow or not DetailsRaidHistoryWindow.Initialized) then
|
|
|
|
DetailsRaidHistoryWindow.Initialized = true
|
|
|
|
local statisticsFrame = DetailsRaidHistoryWindow or CreateFrame("frame", "DetailsRaidHistoryWindow", UIParent, "BackdropTemplate")
|
|
statisticsFrame:SetPoint("center", UIParent, "center")
|
|
statisticsFrame:SetFrameStrata("HIGH")
|
|
statisticsFrame:SetToplevel(true)
|
|
|
|
statisticsFrame:SetMovable(true)
|
|
statisticsFrame:SetWidth(850)
|
|
statisticsFrame:SetHeight(500)
|
|
table.insert(UISpecialFrames, "DetailsRaidHistoryWindow")
|
|
|
|
function statisticsFrame.OpenDB()
|
|
local db = Details.storage:OpenRaidStorage()
|
|
if (not db) then
|
|
Details:Msg(Loc ["STRING_GUILDDAMAGERANK_DATABASEERROR"])
|
|
return
|
|
end
|
|
return db
|
|
end
|
|
|
|
local db = statisticsFrame.OpenDB()
|
|
if (not db) then
|
|
return
|
|
end
|
|
|
|
statisticsFrame.Mode = 2
|
|
|
|
DF:ApplyStandardBackdrop(statisticsFrame)
|
|
|
|
--create title bar
|
|
local titlebar = DF:CreateTitleBar(statisticsFrame, "Details! " .. Loc ["STRING_STATISTICS"])
|
|
titlebar.CloseButton:SetScript("OnClick", function() statisticsFrame:GetParent():Hide() end)
|
|
|
|
--STRING_GUILDDAMAGERANK_TUTORIAL_DESC
|
|
--STRING_OPTIONS_CHART_CLOSE
|
|
|
|
--background
|
|
local background = statisticsFrame:CreateTexture("$parentBackgroundImage", "border")
|
|
background:SetAlpha(0.3)
|
|
background:SetPoint("topleft", statisticsFrame, "topleft", 6, -65)
|
|
background:SetPoint("bottomright", statisticsFrame, "bottomright", -10, 28)
|
|
|
|
--separate menu and main list
|
|
local div = statisticsFrame:CreateTexture(nil, "artwork")
|
|
div:SetTexture([[Interface\ACHIEVEMENTFRAME\UI-Achievement-MetalBorder-Left]])
|
|
div:SetAlpha(0.1)
|
|
div:SetPoint("topleft", statisticsFrame, "topleft", 180, -64)
|
|
div:SetHeight(574)
|
|
|
|
--select history or guild rank
|
|
local options_switch_template = DF:GetTemplate("switch", "OPTIONS_CHECKBOX_TEMPLATE")
|
|
local options_text_template = DF:GetTemplate("font", "OPTIONS_FONT_TEMPLATE")
|
|
local options_button_template = DF:GetTemplate("button", "OPTIONS_BUTTON_TEMPLATE")
|
|
|
|
local selectKillTimeline = function()
|
|
statisticsFrame.GuildRankCheckBox:SetValue(false)
|
|
statisticsFrame.HistoryCheckBox:SetValue(true)
|
|
statisticsFrame.Mode = 1
|
|
statisticsFrame:Refresh()
|
|
statisticsFrame.ReportButton:Hide()
|
|
end
|
|
|
|
local selectGuildRank = function()
|
|
statisticsFrame.HistoryCheckBox:SetValue(false)
|
|
statisticsFrame.GuildRankCheckBox:SetValue(true)
|
|
statisticsFrame.select_player:Select(1, true)
|
|
statisticsFrame.select_player2:Hide()
|
|
statisticsFrame.select_player2_label:Hide()
|
|
statisticsFrame.Mode = 2
|
|
statisticsFrame:Refresh()
|
|
statisticsFrame.ReportButton:Show()
|
|
end
|
|
|
|
--kill timeline
|
|
local HistoryCheckBox, HistoryLabel = DF:CreateSwitch(statisticsFrame, selectKillTimeline, false, 18, 18, "", "", "HistoryCheckBox", nil, nil, nil, nil, Loc ["STRING_GUILDDAMAGERANK_SHOWHISTORY"], options_switch_template) --, options_text_template
|
|
HistoryLabel:ClearAllPoints()
|
|
HistoryCheckBox:ClearAllPoints()
|
|
HistoryCheckBox:SetPoint("topleft", statisticsFrame, "topleft", 100, -34)
|
|
HistoryLabel:SetPoint("left", HistoryCheckBox, "right", 2, 0)
|
|
HistoryCheckBox:SetAsCheckBox()
|
|
|
|
--guildrank
|
|
local GuildRankCheckBox, GuildRankLabel = DF:CreateSwitch(statisticsFrame, selectGuildRank, true, 18, 18, "", "", "GuildRankCheckBox", nil, nil, nil, nil, Loc ["STRING_GUILDDAMAGERANK_SHOWRANK"], options_switch_template) --, options_text_template
|
|
GuildRankLabel:ClearAllPoints()
|
|
GuildRankCheckBox:ClearAllPoints()
|
|
GuildRankCheckBox:SetPoint("topleft", statisticsFrame, "topleft", 240, -34)
|
|
GuildRankLabel:SetPoint("left", GuildRankCheckBox, "right", 2, 0)
|
|
GuildRankCheckBox:SetAsCheckBox()
|
|
|
|
--guild sync
|
|
local doGuildSync = function()
|
|
statisticsFrame.RequestedAmount = 0
|
|
statisticsFrame.DownloadedAmount = 0
|
|
statisticsFrame.EstimateSize = 0
|
|
statisticsFrame.DownloadedSize = 0
|
|
statisticsFrame.SyncStartTime = time()
|
|
|
|
Details.storage:DBGuildSync()
|
|
statisticsFrame.GuildSyncButton:Disable()
|
|
|
|
if (not statisticsFrame.SyncTexture) then
|
|
local workingFrame = CreateFrame("frame", nil, statisticsFrame, "BackdropTemplate")
|
|
statisticsFrame.WorkingFrame = workingFrame
|
|
workingFrame:SetSize(1, 1)
|
|
statisticsFrame.SyncTextureBackground = workingFrame:CreateTexture(nil, "border")
|
|
statisticsFrame.SyncTextureBackground:SetPoint("bottomright", statisticsFrame, "bottomright", -5, -1)
|
|
statisticsFrame.SyncTextureBackground:SetTexture([[Interface\COMMON\StreamBackground]])
|
|
statisticsFrame.SyncTextureBackground:SetSize(32, 32)
|
|
|
|
statisticsFrame.SyncTextureCircle = workingFrame:CreateTexture(nil, "artwork")
|
|
statisticsFrame.SyncTextureCircle:SetPoint("center", statisticsFrame.SyncTextureBackground, "center", 0, 0)
|
|
statisticsFrame.SyncTextureCircle:SetTexture([[Interface\COMMON\StreamCircle]])
|
|
statisticsFrame.SyncTextureCircle:SetSize(32, 32)
|
|
|
|
statisticsFrame.SyncTextureGrade = workingFrame:CreateTexture(nil, "overlay")
|
|
statisticsFrame.SyncTextureGrade:SetPoint("center", statisticsFrame.SyncTextureBackground, "center", 0, 0)
|
|
statisticsFrame.SyncTextureGrade:SetTexture([[Interface\COMMON\StreamFrame]])
|
|
statisticsFrame.SyncTextureGrade:SetSize(32, 32)
|
|
|
|
local animationHub = DF:CreateAnimationHub(workingFrame)
|
|
animationHub:SetLooping("Repeat")
|
|
statisticsFrame.WorkingAnimation = animationHub
|
|
|
|
local rotation = DF:CreateAnimation(animationHub, "ROTATION", 1, 3, -360)
|
|
rotation:SetTarget(statisticsFrame.SyncTextureCircle)
|
|
|
|
statisticsFrame.SyncText = workingFrame:CreateFontString(nil, "border", "GameFontNormal")
|
|
statisticsFrame.SyncText:SetPoint("right", statisticsFrame.SyncTextureBackground, "left", 0, 0)
|
|
statisticsFrame.SyncText:SetText("working")
|
|
|
|
local endAnimationHub = DF:CreateAnimationHub(workingFrame, nil, function() workingFrame:Hide() end)
|
|
DF:CreateAnimation(endAnimationHub, "ALPHA", 1, 0.5, 1, 0)
|
|
statisticsFrame.EndAnimationHub = endAnimationHub
|
|
end
|
|
|
|
statisticsFrame.WorkingFrame:Show()
|
|
statisticsFrame.WorkingAnimation:Play()
|
|
|
|
C_Timer.NewTicker(10, function(self)
|
|
if (not Details.LastGuildSyncReceived) then
|
|
statisticsFrame.GuildSyncButton:Enable()
|
|
statisticsFrame.EndAnimationHub:Play()
|
|
|
|
elseif (Details.LastGuildSyncReceived+10 < GetTime()) then
|
|
statisticsFrame.GuildSyncButton:Enable()
|
|
statisticsFrame.EndAnimationHub:Play()
|
|
self:Cancel()
|
|
end
|
|
end)
|
|
end
|
|
|
|
local guildSyncButton = DF:CreateButton(statisticsFrame, doGuildSync, 130, 20, Loc ["STRING_GUILDDAMAGERANK_SYNCBUTTONTEXT"], nil, nil, nil, "GuildSyncButton", nil, nil, options_button_template, options_text_template)
|
|
guildSyncButton:SetPoint("topright", statisticsFrame, "topright", -20, -34)
|
|
guildSyncButton:SetIcon([[Interface\GLUES\CharacterSelect\RestoreButton]], 12, 12, "overlay", {0.2, .8, 0.2, .8}, nil, 4)
|
|
|
|
--listen to comm events
|
|
local eventListener = Details:CreateEventListener()
|
|
|
|
function eventListener:OnCommReceived(event, length, prefix, playerName, realmName, detailsVersion, guildSyncID, data)
|
|
if (prefix == CONST_GUILD_SYNC) then
|
|
--print(event, length, prefix, playerName, realmName, detailsVersion, guildSyncID, data)
|
|
|
|
--received a list of encounter IDs
|
|
if (guildSyncID == "L") then
|
|
|
|
--received one encounter table
|
|
elseif (guildSyncID == "A") then
|
|
if (not statisticsFrame.RequestedAmount) then
|
|
--if the receiving player reloads, f.RequestedAmount is nil
|
|
return
|
|
end
|
|
statisticsFrame.DownloadedAmount = (statisticsFrame.DownloadedAmount or 0) + 1
|
|
|
|
--size = 1 byte per characters in the string
|
|
statisticsFrame.EstimateSize = length * statisticsFrame.RequestedAmount > statisticsFrame.EstimateSize and length * statisticsFrame.RequestedAmount or statisticsFrame.RequestedAmount
|
|
statisticsFrame.DownloadedSize = statisticsFrame.DownloadedSize + length
|
|
local downloadSpeed = statisticsFrame.DownloadedSize / (time() - statisticsFrame.SyncStartTime)
|
|
|
|
statisticsFrame.SyncText:SetText("working [downloading " .. statisticsFrame.DownloadedAmount .. "/" .. statisticsFrame.RequestedAmount .. ", " .. format("%.2f", downloadSpeed/1024) .. "Kbps]")
|
|
end
|
|
end
|
|
end
|
|
|
|
function eventListener:OnCommSent(event, length, prefix, playerName, realmName, detailsVersion, guildSyncID, missingIDs, arg8, arg9)
|
|
if (prefix == CONST_GUILD_SYNC) then
|
|
--print(event, length, prefix, playerName, realmName, detailsVersion, guildSyncID, missingIDs, arg8, arg9)
|
|
|
|
--requested a list of encounters
|
|
if (guildSyncID == "R") then
|
|
|
|
--requested to download a selected list of encounter tables
|
|
elseif (guildSyncID == "G") then
|
|
statisticsFrame.RequestedAmount = statisticsFrame.RequestedAmount + #missingIDs
|
|
statisticsFrame.SyncText:SetText("working [downloading " .. statisticsFrame.DownloadedAmount .. "/" .. statisticsFrame.RequestedAmount .. "]")
|
|
end
|
|
end
|
|
end
|
|
|
|
eventListener:RegisterEvent("COMM_EVENT_RECEIVED", "OnCommReceived")
|
|
eventListener:RegisterEvent("COMM_EVENT_SENT", "OnCommSent")
|
|
|
|
--report results
|
|
function statisticsFrame.BuildReport()
|
|
if (statisticsFrame.LatestResourceTable) then
|
|
local reportFunc = function(IsCurrent, IsReverse, AmtLines)
|
|
local bossName = statisticsFrame.select_boss.label:GetText()
|
|
local bossDiff = statisticsFrame.select_diff.label:GetText()
|
|
local guildName = statisticsFrame.select_guild.label:GetText()
|
|
local reportTable = {"Details!: DPS Rank for: " .. (bossDiff or "") .. " " .. (bossName or "--x--x--") .. " <" .. (guildName or "") .. ">"}
|
|
local result = {}
|
|
|
|
for i = 1, AmtLines do
|
|
if (statisticsFrame.LatestResourceTable[i]) then
|
|
local playerName = statisticsFrame.LatestResourceTable[i][1]
|
|
playerName = playerName:gsub("%|c%x%x%x%x%x%x%x%x", "")
|
|
playerName = playerName:gsub("%|r", "")
|
|
playerName = playerName:gsub(".*%s", "")
|
|
table.insert(result, {playerName, statisticsFrame.LatestResourceTable[i][2]})
|
|
else
|
|
break
|
|
end
|
|
end
|
|
|
|
Details:FormatReportLines(reportTable, result)
|
|
Details:SendReportLines(reportTable)
|
|
end
|
|
|
|
Details:SendReportWindow(reportFunc, nil, nil, true)
|
|
end
|
|
end
|
|
|
|
local reportButton = DF:CreateButton(statisticsFrame, statisticsFrame.BuildReport, 130, 20, Loc ["STRING_OPTIONS_REPORT_ANCHOR"]:gsub(":", ""), nil, nil, nil, "ReportButton", nil, nil, options_button_template, options_text_template)
|
|
reportButton:SetPoint("right", guildSyncButton, "left", -2, 0)
|
|
reportButton:SetIcon([[Interface\GLUES\CharacterSelect\RestoreButton]], 12, 12, "overlay", {0.2, .8, 0.2, .8}, nil, 4)
|
|
|
|
--
|
|
function statisticsFrame:SetBackgroundImage(encounterId)
|
|
local instanceId = Details:GetInstanceIdFromEncounterId(encounterId)
|
|
if (instanceId) then
|
|
local file, L, R, T, B = Details:GetRaidBackground(instanceId)
|
|
--print("file:", file)
|
|
--can't get the image, looks to be restricted
|
|
--[[
|
|
if (file) then
|
|
background:SetTexture(file)
|
|
background:SetTexCoord(L, R, T, B)
|
|
else
|
|
background:SetColorTexture(0.2, 0.2, 0.2, 0.8)
|
|
end
|
|
--]]
|
|
background:SetColorTexture(0.2, 0.2, 0.2, 0.8)
|
|
end
|
|
end
|
|
|
|
--window script handlers
|
|
statisticsFrame:SetScript("OnMouseDown", function(self, button)
|
|
if (self.isMoving) then
|
|
return
|
|
end
|
|
if (button == "RightButton") then
|
|
self:Hide()
|
|
else
|
|
self:StartMoving()
|
|
self.isMoving = true
|
|
end
|
|
end)
|
|
|
|
statisticsFrame:SetScript("OnMouseUp", function(self, button)
|
|
if (self.isMoving and button == "LeftButton") then
|
|
self:StopMovingOrSizing()
|
|
self.isMoving = nil
|
|
end
|
|
end)
|
|
|
|
statisticsFrame:SetScript("OnHide", function()
|
|
--save latest shown state
|
|
statisticsFrame.LatestSelection = statisticsFrame.LatestSelection or {}
|
|
statisticsFrame.LatestSelection.Raid = DetailsRaidHistoryWindow.select_raid.value
|
|
statisticsFrame.LatestSelection.Boss = DetailsRaidHistoryWindow.select_boss.value
|
|
statisticsFrame.LatestSelection.Diff = DetailsRaidHistoryWindow.select_diff.value
|
|
statisticsFrame.LatestSelection.Role = DetailsRaidHistoryWindow.select_role.value
|
|
statisticsFrame.LatestSelection.Guild = DetailsRaidHistoryWindow.select_guild.value
|
|
statisticsFrame.LatestSelection.PlayerBase = DetailsRaidHistoryWindow.select_player.value
|
|
statisticsFrame.LatestSelection.PlayerName = DetailsRaidHistoryWindow.select_player2.value
|
|
end)
|
|
|
|
local dropdownWidth = 160
|
|
local icon = [[Interface\FriendsFrame\battlenet-status-offline]]
|
|
|
|
local difficultyList = {}
|
|
local raidList = {}
|
|
local bossList = {}
|
|
local guildList = {}
|
|
|
|
local sortAlphabetical = function(a,b) return a.value < b.value end
|
|
|
|
local onSelect = function()
|
|
if (statisticsFrame.Refresh) then
|
|
statisticsFrame:Refresh()
|
|
end
|
|
end
|
|
|
|
--select raid:
|
|
local onRaidSelect = function(_, _, raid)
|
|
Details.rank_window.last_raid = raid
|
|
statisticsFrame:UpdateDropdowns(true)
|
|
onSelect()
|
|
end
|
|
|
|
local buildRaidList = function()
|
|
return raidList
|
|
end
|
|
|
|
local raidDropdown = DF:CreateDropDown(statisticsFrame, buildRaidList, 1, dropdownWidth, 20, "select_raid")
|
|
local raidString = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_RAID"] .. ":", _, _, "GameFontNormal", "select_raid_label")
|
|
raidDropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select boss:
|
|
local onSelectBoss = function(_, _, boss)
|
|
onSelect()
|
|
end
|
|
|
|
local buildBossList = function()
|
|
return bossList
|
|
end
|
|
|
|
local bossDropdown = DF:CreateDropDown(statisticsFrame, buildBossList, 1, dropdownWidth, 20, "select_boss")
|
|
local bossString = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_BOSS"] .. ":", _, _, "GameFontNormal", "select_boss_label")
|
|
bossDropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select difficulty:
|
|
local onDifficultySelect = function(_, _, diff)
|
|
Details.rank_window.last_difficulty = diff
|
|
onSelect()
|
|
end
|
|
|
|
local buildDifficultyList = function()
|
|
return difficultyList
|
|
end
|
|
|
|
local difficultyDropdown = DF:CreateDropDown(statisticsFrame, buildDifficultyList, 1, dropdownWidth, 20, "select_diff")
|
|
local difficultyString = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_DIFF"] .. ":", _, _, "GameFontNormal", "select_diff_label")
|
|
difficultyDropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select role:
|
|
local onRoleSelect = function(_, _, role)
|
|
onSelect()
|
|
end
|
|
|
|
local buildRoleList = function()
|
|
return {
|
|
{value = "damage", label = "Damager", icon = icon, onclick = onRoleSelect},
|
|
{value = "healing", label = "Healer", icon = icon, onclick = onRoleSelect}
|
|
}
|
|
end
|
|
|
|
local role_dropdown = DF:CreateDropDown (statisticsFrame, buildRoleList, 1, dropdownWidth, 20, "select_role")
|
|
local role_string = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_ROLE"] .. ":", _, _, "GameFontNormal", "select_role_label")
|
|
role_dropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select guild:
|
|
local onGuildSelect = function(_, _, guild)
|
|
onSelect()
|
|
end
|
|
|
|
local buildGuildList = function()
|
|
return guildList
|
|
end
|
|
|
|
local guildDropdown = DF:CreateDropDown(statisticsFrame, buildGuildList, 1, dropdownWidth, 20, "select_guild")
|
|
local guildString = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_GUILD"] .. ":", _, _, "GameFontNormal", "select_guild_label")
|
|
guildDropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select playerbase:
|
|
local onPlayerSelect = function(_, _, player)
|
|
onSelect()
|
|
end
|
|
|
|
local buildPlayerList = function()
|
|
return {
|
|
{value = 1, label = Loc ["STRING_GUILDDAMAGERANK_PLAYERBASE_RAID"], icon = icon, onclick = onPlayerSelect},
|
|
{value = 2, label = Loc ["STRING_GUILDDAMAGERANK_PLAYERBASE_INDIVIDUAL"], icon = icon, onclick = onPlayerSelect},
|
|
}
|
|
end
|
|
|
|
local player_dropdown = DF:CreateDropDown(statisticsFrame, buildPlayerList, 1, dropdownWidth, 20, "select_player")
|
|
local player_string = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_PLAYERBASE"] .. ":", _, _, "GameFontNormal", "select_player_label")
|
|
player_dropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
--select player:
|
|
local onPlayer2Select = function(_, _, player)
|
|
statisticsFrame.latest_player_selected = player
|
|
statisticsFrame:BuildPlayerTable(player)
|
|
end
|
|
|
|
local buildPlayer2List = function()
|
|
local encounterTable, guild, role = unpack(statisticsFrame.build_player2_data or {})
|
|
local t = {}
|
|
local alreadyListed = {}
|
|
if (encounterTable) then
|
|
for encounterIndex, encounter in ipairs(encounterTable) do
|
|
if (encounter.guild == guild) then
|
|
local roleTable = encounter [role]
|
|
for playerName, _ in pairs(roleTable) do
|
|
if (not alreadyListed [playerName]) then
|
|
table.insert(t, {value = playerName, label = playerName, icon = icon, onclick = onPlayer2Select})
|
|
alreadyListed [playerName] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(t, sortAlphabetical)
|
|
return t
|
|
end
|
|
|
|
local player2Dropdown = DF:CreateDropDown(statisticsFrame, buildPlayer2List, 1, dropdownWidth, 20, "select_player2")
|
|
local player2String = DF:CreateLabel(statisticsFrame, Loc ["STRING_GUILDDAMAGERANK_PLAYERBASE_PLAYER"] .. ":", _, _, "GameFontNormal", "select_player2_label")
|
|
player2Dropdown:SetTemplate(DF:GetTemplate("dropdown", "OPTIONS_DROPDOWN_TEMPLATE"))
|
|
|
|
function statisticsFrame:UpdateDropdowns(bDoNotSelectRaid)
|
|
local currentGuild = guildDropdown.value
|
|
|
|
--wipe data
|
|
Details:Destroy(difficultyList)
|
|
Details:Destroy(bossList)
|
|
Details:Destroy(raidList)
|
|
Details:Destroy(guildList)
|
|
|
|
local bossRepeated = {}
|
|
local raidRepeated = {}
|
|
local guildRepeated = {}
|
|
|
|
local raidSelected = _G.DetailsRaidHistoryWindow.select_raid:GetValue()
|
|
db = statisticsFrame.OpenDB()
|
|
if (not db) then
|
|
return
|
|
end
|
|
|
|
--make a list of raids and bosses that belong to the current expansion
|
|
local bossIndexedTable, bossInfoTable, raidInfoTable = Details:GetExpansionBossList()
|
|
local allowedBosses = {}
|
|
for bossId, bossTable in pairs(bossInfoTable) do
|
|
allowedBosses[bossTable.dungeonEncounterID] = true --dungeonEncounterID is the id used in the encounter_start event
|
|
end
|
|
|
|
local allowedKeysForDifficulty = {
|
|
[14] = true, --normal
|
|
[15] = true, --heroic
|
|
[16] = true, --mythic
|
|
--[17] = true, --raid finder
|
|
}
|
|
|
|
local playerGuildName = GetGuildInfo("player")
|
|
--local playerGuildName = "Patifaria" --debug
|
|
|
|
for difficulty, encounterIdTable in pairs(db) do
|
|
if (type(difficulty) == "number" and allowedKeysForDifficulty[difficulty]) then
|
|
for dungeonEncounterID, encounterTable in pairs(encounterIdTable) do
|
|
if (allowedBosses[dungeonEncounterID]) then
|
|
if (not bossRepeated[dungeonEncounterID]) then
|
|
local encounter, instance = Details:GetBossEncounterDetailsFromEncounterId(nil, dungeonEncounterID) --deprecated
|
|
|
|
if (encounter) then
|
|
local instanceId = Details:GetInstanceIdFromEncounterId(dungeonEncounterID)
|
|
if (raidSelected == instanceId) then
|
|
table.insert(bossList, {value = dungeonEncounterID, label = encounter.boss, icon = icon, onclick = onSelectBoss})
|
|
bossRepeated[dungeonEncounterID] = true
|
|
end
|
|
|
|
if (not raidRepeated[instance.name]) then
|
|
local raidData
|
|
for raidInstanceID, thisRaidData in pairs(raidInfoTable) do
|
|
if (thisRaidData.raidName == instance.name) then
|
|
raidData = thisRaidData
|
|
break
|
|
end
|
|
end
|
|
|
|
if (raidData) then
|
|
local instanceName = raidData.raidName
|
|
local raidIcon = raidData.raidIcon
|
|
local raidIconCoords = raidData.raidIconCoords
|
|
|
|
table.insert(raidList, {value = instance.id, label = instanceName, icon = raidIcon, texcoord = raidIconCoords, onclick = onRaidSelect})
|
|
raidRepeated[instance.name] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--add guild name to the dropdown
|
|
if (playerGuildName) then
|
|
if (not guildRepeated[playerGuildName]) then
|
|
table.insert(guildList, {value = playerGuildName, label = playerGuildName, icon = icon, onclick = onGuildSelect})
|
|
guildRepeated[playerGuildName] = true
|
|
end
|
|
else
|
|
for index, encounter in ipairs(encounterTable) do
|
|
local guild = encounter.guild
|
|
if (not guildRepeated[guild]) then
|
|
table.insert(guildList, {value = guild, label = guild, icon = icon, onclick = onGuildSelect})
|
|
guildRepeated[guild] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
--add the difficult to the dropdown
|
|
if (difficulty == 14) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Normal") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, 1, {value = difficulty, label = "Normal", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
|
|
elseif (difficulty == 15) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Heroic") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, 1, {value = difficulty, label = "Heroic", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
|
|
elseif (difficulty == 16) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Mythic") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, {value = difficulty, label = "Mythic", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(bossList, function(t1, t2) return t1.label < t2.label end)
|
|
|
|
difficultyDropdown:Refresh()
|
|
guildDropdown:Refresh()
|
|
if (not bDoNotSelectRaid) then
|
|
raidDropdown:Refresh()
|
|
end
|
|
bossDropdown:Refresh()
|
|
|
|
C_Timer.After(1, function()
|
|
if (not bDoNotSelectRaid) then
|
|
raidDropdown:Select(1, true)
|
|
end
|
|
|
|
difficultyDropdown:Select(1, true)
|
|
|
|
if (currentGuild) then
|
|
guildDropdown:Select(currentGuild)
|
|
else
|
|
guildDropdown:Select(1, true)
|
|
end
|
|
|
|
bossDropdown:Select(1, true)
|
|
end)
|
|
end
|
|
|
|
function statisticsFrame.UpdateBossDropdown()
|
|
local allowedKeysForDifficulty = {
|
|
[14] = true, --normal
|
|
[15] = true, --heroic
|
|
[16] = true, --mythic
|
|
--[17] = true, --raid finder
|
|
}
|
|
|
|
--make a list of raids and bosses that belong to the current expansion
|
|
local bossIndexedTable, bossInfoTable = Details:GetExpansionBossList()
|
|
local allowedBosses = {}
|
|
for bossId, bossTable in pairs(bossInfoTable) do
|
|
allowedBosses[bossTable.dungeonEncounterID] = true
|
|
end
|
|
|
|
local raidSelected = DetailsRaidHistoryWindow.select_raid:GetValue()
|
|
local bossRepeated = {}
|
|
Details:Destroy(bossList)
|
|
Details:Destroy(difficultyList)
|
|
|
|
for difficulty, encounterIdTable in pairs(db) do
|
|
if (type(difficulty) == "number" and allowedKeysForDifficulty[difficulty]) then
|
|
for dungeonEncounterID, encounterTable in pairs(encounterIdTable) do
|
|
if (allowedBosses[dungeonEncounterID]) then
|
|
if (not bossRepeated[dungeonEncounterID]) then
|
|
local encounter, instance = Details:GetBossEncounterDetailsFromEncounterId(nil, dungeonEncounterID) --deprecated
|
|
|
|
if (encounter) then
|
|
local instanceId = Details:GetInstanceIdFromEncounterId(dungeonEncounterID)
|
|
if (raidSelected == instanceId) then
|
|
table.insert(bossList, {value = dungeonEncounterID, label = encounter.boss, icon = icon, onclick = onSelectBoss})
|
|
bossRepeated[dungeonEncounterID] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
--add the difficult to the dropdown
|
|
if (difficulty == 14) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Normal") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, 1, {value = difficulty, label = "Normal", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
|
|
elseif (difficulty == 15) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Heroic") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, 1, {value = difficulty, label = "Heroic", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
|
|
elseif (difficulty == 16) then
|
|
local alreadyHave = false
|
|
for i, t in ipairs(difficultyList) do
|
|
if (t.label == "Mythic") then
|
|
alreadyHave = true
|
|
end
|
|
end
|
|
if (not alreadyHave) then
|
|
table.insert(difficultyList, {value = difficulty, label = "Mythic", icon = icon, onclick = onDifficultySelect})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
table.sort(bossList, function(t1, t2) return t1.label < t2.label end)
|
|
bossDropdown:Refresh()
|
|
end
|
|
|
|
--anchors:
|
|
raidString:SetPoint("topleft", statisticsFrame, "topleft", 10, -70)
|
|
raidDropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -85)
|
|
|
|
bossString:SetPoint("topleft", statisticsFrame, "topleft", 10, -110)
|
|
bossDropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -125)
|
|
|
|
difficultyString:SetPoint("topleft", statisticsFrame, "topleft", 10, -150)
|
|
difficultyDropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -165)
|
|
|
|
role_string:SetPoint("topleft", statisticsFrame, "topleft", 10, -190)
|
|
role_dropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -205)
|
|
|
|
guildString:SetPoint("topleft", statisticsFrame, "topleft", 10, -230)
|
|
guildDropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -245)
|
|
|
|
player_string:SetPoint("topleft", statisticsFrame, "topleft", 10, -270)
|
|
player_dropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -285)
|
|
|
|
player2String:SetPoint("topleft", statisticsFrame, "topleft", 10, -310)
|
|
player2Dropdown:SetPoint("topleft", statisticsFrame, "topleft", 10, -325)
|
|
player2String:Hide()
|
|
player2Dropdown:Hide()
|
|
|
|
--refresh the window:
|
|
|
|
function statisticsFrame:BuildPlayerTable(playerName)
|
|
|
|
local encounterTable, guild, role = unpack(statisticsFrame.build_player2_data or {})
|
|
local data = {}
|
|
|
|
if (type(playerName) == "string" and string.len(playerName) > 1) then
|
|
for encounterIndex, encounter in ipairs(encounterTable) do
|
|
if (encounter.guild == guild) then
|
|
local roleTable = encounter [role]
|
|
|
|
local date = encounter.date
|
|
date = date:gsub(".*%s", "")
|
|
date = date:sub (1, -4)
|
|
|
|
local player = roleTable [playerName]
|
|
|
|
if (player) then
|
|
|
|
--tinsert(data, {text = date, value = player[1], data = player, fulldate = encounter.date, elapsed = encounter.elapsed})
|
|
table.insert(data, {text = date, value = player[1]/encounter.elapsed, utext = Details:ToK2 (player[1]/encounter.elapsed), data = player, fulldate = encounter.date, elapsed = encounter.elapsed})
|
|
end
|
|
end
|
|
end
|
|
|
|
--update graphic
|
|
if (not statisticsFrame.gframe) then
|
|
local onenter = function(self)
|
|
GameCooltip:Reset()
|
|
GameCooltip:SetType("tooltip")
|
|
GameCooltip:Preset(2)
|
|
|
|
GameCooltip:AddLine("Total Done:", Details:ToK2 (self.data.value), 1, "white")
|
|
GameCooltip:AddLine("Dps:", Details:ToK2 (self.data.value / self.data.elapsed), 1, "white")
|
|
GameCooltip:AddLine("Item Level:", floor(self.data.data [2]), 1, "white")
|
|
GameCooltip:AddLine("Date:", self.data.fulldate:gsub(".*%s", ""), 1, "white")
|
|
|
|
GameCooltip:SetOwner(self.ball.tooltip_anchor)
|
|
GameCooltip:Show()
|
|
end
|
|
|
|
local onleave = function(self)
|
|
GameCooltip:Hide()
|
|
end
|
|
|
|
statisticsFrame.gframe = DF:CreateGFrame(statisticsFrame, 650, 400, 35, onenter, onleave, "gframe", "$parentGF")
|
|
statisticsFrame.gframe:SetPoint("topleft", statisticsFrame, "topleft", 190, -65)
|
|
end
|
|
|
|
statisticsFrame.gframe:Reset()
|
|
statisticsFrame.gframe:UpdateLines(data)
|
|
end
|
|
end
|
|
|
|
local fillpanel = DF:NewFillPanel(statisticsFrame, {}, "$parentFP", "fillpanel", 710, 501, false, false, true, nil)
|
|
fillpanel:SetPoint("topleft", statisticsFrame, "topleft", 195, -65)
|
|
|
|
function statisticsFrame:BuildGuildRankTable(encounterTable, guild, role)
|
|
|
|
local header = {{name = "Player Name", type = "text"}, {name = "Per Second", type = "text"}, {name = "Total", type = "text"}, {name = "Length", type = "text"}, {name = "Item Level", type = "text"}, {name = "Date", type = "text"}}
|
|
local players = {}
|
|
local players_index = {}
|
|
|
|
local playerScore = {}
|
|
|
|
--get the best of each player
|
|
for encounterIndex, encounter in ipairs(encounterTable) do
|
|
if (encounter.guild == guild) then
|
|
local roleTable = encounter[role]
|
|
|
|
local date = encounter.date
|
|
date = date:gsub(".*%s", "")
|
|
date = date:sub (1, -4)
|
|
|
|
for playerName, playerTable in pairs(roleTable) do
|
|
if (not playerScore[playerName]) then
|
|
playerScore [playerName] = {
|
|
total = 0,
|
|
ps = 0,
|
|
ilvl = 0,
|
|
date = 0,
|
|
class = 0,
|
|
length = 0,
|
|
}
|
|
end
|
|
|
|
local total = playerTable [1]
|
|
local dps = total / encounter.elapsed
|
|
|
|
--if (total > playerScore [playerName].total) then
|
|
if (dps > playerScore[playerName].ps) then
|
|
playerScore[playerName].total = total
|
|
playerScore[playerName].ps = total / encounter.elapsed
|
|
playerScore[playerName].ilvl = playerTable [2]
|
|
playerScore[playerName].length = encounter.elapsed
|
|
playerScore[playerName].date = date
|
|
playerScore[playerName].class = playerTable [3]
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local sortTable = {}
|
|
for playerName, t in pairs(playerScore) do
|
|
local className = select(2, GetClassInfo(t.class or 0))
|
|
local classColor = "FFFFFFFF"
|
|
if (className) then
|
|
classColor = RAID_CLASS_COLORS[className] and RAID_CLASS_COLORS[className].colorStr
|
|
end
|
|
|
|
local playerNameFormated = Details:GetOnlyName(playerName)
|
|
table.insert(sortTable, {
|
|
"|c" .. classColor .. playerNameFormated .. "|r",
|
|
Details:comma_value (t.ps),
|
|
Details:ToK2 (t.total),
|
|
DF:IntegerToTimer(t.length),
|
|
floor(t.ilvl),
|
|
t.date,
|
|
t.total,
|
|
t.ps,
|
|
})
|
|
end
|
|
|
|
table.sort(sortTable, function(a, b) return a[8] > b[8] end)
|
|
|
|
--add the number before the player name
|
|
for i = 1, #sortTable do
|
|
local t = sortTable [i]
|
|
t[1] = i .. ". " .. t[1]
|
|
end
|
|
|
|
fillpanel:SetFillFunction(function(index) return sortTable [index] end)
|
|
fillpanel:SetTotalFunction(function() return #sortTable end)
|
|
fillpanel:UpdateRows(header)
|
|
fillpanel:Refresh()
|
|
|
|
statisticsFrame.LatestResourceTable = sortTable
|
|
end
|
|
|
|
function statisticsFrame:BuildRaidTable(encounterTable, guild, role)
|
|
if (statisticsFrame.Mode == 2) then
|
|
statisticsFrame:BuildGuildRankTable(encounterTable, guild, role)
|
|
return
|
|
end
|
|
|
|
local header = {{name = "Player Name", type = "text"}} -- , width = 90
|
|
local players = {}
|
|
local players_index = {}
|
|
local player_class = {}
|
|
local amt_encounters = 0
|
|
|
|
for encounterIndex, encounter in ipairs(encounterTable) do
|
|
if (encounter.guild == guild) then
|
|
local roleTable = encounter [role]
|
|
|
|
local date = encounter.date
|
|
date = date:gsub(".*%s", "")
|
|
date = date:sub (1, -4)
|
|
amt_encounters = amt_encounters + 1
|
|
|
|
table.insert(header, {name = date, type = "text"})
|
|
|
|
for playerName, playerTable in pairs(roleTable) do
|
|
local index = players_index [playerName]
|
|
local player
|
|
|
|
if (not index) then
|
|
player = {playerName}
|
|
player_class [playerName] = playerTable [3]
|
|
for i = 1, amt_encounters-1 do
|
|
table.insert(player, "")
|
|
end
|
|
table.insert(player, Details:ToK2 (playerTable [1] / encounter.elapsed))
|
|
table.insert(players, player)
|
|
players_index [playerName] = #players
|
|
|
|
--print("not index", playerName, amt_encounters, date, 2, amt_encounters-1)
|
|
else
|
|
player = players [index]
|
|
for i = #player+1, amt_encounters-1 do
|
|
table.insert(player, "")
|
|
end
|
|
table.insert(player, Details:ToK2 (playerTable [1] / encounter.elapsed))
|
|
end
|
|
|
|
end
|
|
end
|
|
end
|
|
|
|
--sort alphabetical
|
|
table.sort (players, function(a, b) return a[1] < b[1] end)
|
|
|
|
for index, playerTable in ipairs(players) do
|
|
for i = #playerTable, amt_encounters do
|
|
table.insert(playerTable, "")
|
|
end
|
|
|
|
local className = select(2, GetClassInfo (player_class [playerTable [1]] or 0))
|
|
if (className) then
|
|
local playerNameFormated = Details:GetOnlyName(playerTable[1])
|
|
local classColor = RAID_CLASS_COLORS [className] and RAID_CLASS_COLORS [className].colorStr
|
|
playerTable [1] = "|c" .. classColor .. playerNameFormated .. "|r"
|
|
end
|
|
end
|
|
|
|
fillpanel:SetFillFunction (function(index) return players [index] end)
|
|
fillpanel:SetTotalFunction (function() return #players end)
|
|
|
|
fillpanel:UpdateRows (header)
|
|
|
|
fillpanel:Refresh()
|
|
fillpanel:SetPoint("topleft", statisticsFrame, "topleft", 200, -65)
|
|
end
|
|
|
|
function statisticsFrame:Refresh (player_name)
|
|
--build the main table
|
|
local diff = difficultyDropdown.value
|
|
local boss = bossDropdown.value
|
|
local role = role_dropdown.value
|
|
local guild = guildDropdown.value
|
|
local player = player_dropdown.value
|
|
|
|
local diffTable = db [diff]
|
|
|
|
statisticsFrame:SetBackgroundImage(boss)
|
|
|
|
if (diffTable) then
|
|
local encounters = diffTable[boss]
|
|
if (encounters) then
|
|
if (player == 1) then --raid
|
|
fillpanel:Show()
|
|
if (statisticsFrame.gframe) then
|
|
statisticsFrame.gframe:Hide()
|
|
end
|
|
player2String:Hide()
|
|
player2Dropdown:Hide()
|
|
statisticsFrame:BuildRaidTable(encounters, guild, role)
|
|
|
|
elseif (player == 2) then --only one player
|
|
fillpanel:Hide()
|
|
if (statisticsFrame.gframe) then
|
|
statisticsFrame.gframe:Show()
|
|
end
|
|
player2String:Show()
|
|
player2Dropdown:Show()
|
|
statisticsFrame.build_player2_data = {encounters, guild, role}
|
|
player2Dropdown:Refresh()
|
|
|
|
player_name = statisticsFrame.latest_player_selected or player_name
|
|
|
|
if (player_name) then
|
|
player2Dropdown:Select(player_name)
|
|
else
|
|
player2Dropdown:Select(1, true)
|
|
end
|
|
|
|
statisticsFrame:BuildPlayerTable (player2Dropdown.value)
|
|
end
|
|
else
|
|
if (player == 1) then --raid
|
|
fillpanel:Show()
|
|
if (statisticsFrame.gframe) then
|
|
statisticsFrame.gframe:Hide()
|
|
end
|
|
player2String:Hide()
|
|
player2Dropdown:Hide()
|
|
statisticsFrame:BuildRaidTable ({}, guild, role)
|
|
|
|
elseif (player == 2) then --only one player
|
|
fillpanel:Hide()
|
|
if (statisticsFrame.gframe) then
|
|
statisticsFrame.gframe:Show()
|
|
end
|
|
player2String:Show()
|
|
player2Dropdown:Show()
|
|
statisticsFrame.build_player2_data = {{}, guild, role}
|
|
player2Dropdown:Refresh()
|
|
player2Dropdown:Select(1, true)
|
|
statisticsFrame:BuildPlayerTable (player2Dropdown.value)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
statisticsFrame.FirstRun = true
|
|
end --end of DetailsRaidHistoryWindow creation
|
|
|
|
local statsWindow = _G.DetailsRaidHistoryWindow
|
|
|
|
--table means some button send the request - nil for other ways
|
|
if (type(raidName) == "table" or (not raidName and not bossEncounterId and not difficultyId and not playerRole and not guildName and not playerBase and not playerName)) then
|
|
local f = statsWindow
|
|
if (f.LatestSelection) then
|
|
raidName = f.LatestSelection.Raid
|
|
bossEncounterId = f.LatestSelection.Boss
|
|
difficultyId = f.LatestSelection.Diff
|
|
playerRole = f.LatestSelection.Role
|
|
guildName = f.LatestSelection.Guild
|
|
playerBase = f.LatestSelection.PlayerBase
|
|
playerName = f.LatestSelection.PlayerBase
|
|
end
|
|
end
|
|
|
|
if (statsWindow.FirstRun) then
|
|
difficultyId = Details.rank_window.last_difficulty or difficultyId
|
|
|
|
if (IsInGuild()) then
|
|
local guildName = GetGuildInfo("player")
|
|
if (guildName) then
|
|
guildName = guildName
|
|
end
|
|
end
|
|
|
|
if (Details.rank_window.last_raid ~= "") then
|
|
raidName = Details.rank_window.last_raid or raidName
|
|
end
|
|
end
|
|
|
|
if (not statsWindow.UpdateDropdowns) then
|
|
Details:Msg("Failled to load statistics, Details! Storage is disabled?")
|
|
return
|
|
end
|
|
|
|
statsWindow:UpdateDropdowns()
|
|
statsWindow:Refresh()
|
|
statsWindow:Show()
|
|
|
|
if (historyType == 1 or historyType == 2) then
|
|
statsWindow.Mode = historyType
|
|
if (statsWindow.Mode == 1) then
|
|
--overall
|
|
statsWindow.HistoryCheckBox:SetValue(true)
|
|
statsWindow.GuildRankCheckBox:SetValue(false)
|
|
elseif (statsWindow.Mode == 2) then
|
|
--guild rank
|
|
statsWindow.GuildRankCheckBox:SetValue(true)
|
|
statsWindow.HistoryCheckBox:SetValue(false)
|
|
end
|
|
end
|
|
|
|
if (raidName) then
|
|
statsWindow.select_raid:Select(raidName)
|
|
statsWindow:Refresh()
|
|
statsWindow.UpdateBossDropdown()
|
|
end
|
|
|
|
if (bossEncounterId) then
|
|
statsWindow.select_boss:Select(bossEncounterId)
|
|
statsWindow:Refresh()
|
|
end
|
|
|
|
if (difficultyId) then
|
|
statsWindow.select_diff:Select(difficultyId)
|
|
statsWindow:Refresh()
|
|
end
|
|
|
|
if (playerRole) then
|
|
statsWindow.select_role:Select(playerRole)
|
|
statsWindow:Refresh()
|
|
end
|
|
|
|
if (guildName) then
|
|
if (type(guildName) == "boolean") then
|
|
guildName = GetGuildInfo("player")
|
|
end
|
|
statsWindow.select_guild:Select(guildName)
|
|
statsWindow:Refresh()
|
|
end
|
|
|
|
if (playerBase) then
|
|
statsWindow.select_player:Select(playerBase)
|
|
statsWindow:Refresh()
|
|
end
|
|
|
|
if (playerName) then
|
|
statsWindow.select_player2:Refresh()
|
|
statsWindow.select_player2:Select(playerName)
|
|
statsWindow:Refresh (playerName)
|
|
end
|
|
|
|
DetailsPluginContainerWindow.OpenPlugin(statsWindow)
|
|
end
|
|
|