Horyoshi
785 lines
27 KiB
Lua
785 lines
27 KiB
Lua
-- Matrix - Keeper Gnarlmoon Team Assignment Tool
|
|
-- Only usable by Officers and Supreme Leaders
|
|
-- Assigns raid members to Red (Left) or Blue (Right) teams
|
|
|
|
local C = AceLibrary("Crayon-2.0")
|
|
local BC = AceLibrary("Babble-Class-2.2")
|
|
local L = AceLibrary("AceLocale-2.2"):new("shootyepgp")
|
|
|
|
-- Module creation
|
|
sepgp_matrix = sepgp:NewModule("sepgp_matrix", "AceEvent-2.0")
|
|
|
|
-- Local state
|
|
local playerAssignments = {} -- [playerName] = "red" or "blue" or nil
|
|
local raidRoster = {} -- Current raid roster cache
|
|
local matrixFrame = nil
|
|
local playerFrames = {} -- UI frames for each player
|
|
local isUpdating = false
|
|
|
|
-- Constants
|
|
local FRAME_WIDTH = 670
|
|
local FRAME_HEIGHT = 410
|
|
local PLAYER_WIDTH = 105
|
|
local PLAYER_HEIGHT = 16
|
|
local CHECKBOX_SIZE = 12
|
|
local GROUP_HEADER_HEIGHT = 18
|
|
local COLUMNS = 4
|
|
local GROUPS_PER_COLUMN = 2
|
|
|
|
-- Colors
|
|
local COLOR_RED = {r = 0.9, g = 0.2, b = 0.2}
|
|
local COLOR_BLUE = {r = 0.2, g = 0.4, b = 0.9}
|
|
local COLOR_AWKWARD = {r = 0.7, g = 0.7, b = 0.7}
|
|
local COLOR_RED_BG = {r = 0.5, g = 0.1, b = 0.1, a = 0.6}
|
|
local COLOR_BLUE_BG = {r = 0.1, g = 0.2, b = 0.5, a = 0.6}
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Permission Check
|
|
-------------------------------------------------------------------------------
|
|
local function canUseMatrix()
|
|
-- Check if player is in a raid
|
|
if GetNumRaidMembers() == 0 then
|
|
return false, "You must be in a raid to use this feature."
|
|
end
|
|
|
|
-- Check guild rank
|
|
local guildName, guildRankName = GetGuildInfo("player")
|
|
if not guildName then
|
|
return false, "You must be in a guild to use this feature."
|
|
end
|
|
|
|
-- Check for Officer or Supreme leader rank, or raid leader/assistant
|
|
if guildRankName == "Officer" or guildRankName == "Supreme leader" then
|
|
return true
|
|
end
|
|
|
|
-- Also allow raid leaders and assistants
|
|
if IsRaidLeader() or IsRaidOfficer() then
|
|
return true
|
|
end
|
|
|
|
return false, "Only Officers or Supreme Leaders can use this feature."
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Raid Roster Management
|
|
-------------------------------------------------------------------------------
|
|
local function buildRaidRoster()
|
|
local roster = {}
|
|
local numRaid = GetNumRaidMembers()
|
|
|
|
if numRaid == 0 then
|
|
return roster
|
|
end
|
|
|
|
for i = 1, numRaid do
|
|
local name, rank, subgroup, level, class, fileName, zone, online, isDead = GetRaidRosterInfo(i)
|
|
if name then
|
|
table.insert(roster, {
|
|
name = name,
|
|
class = fileName or class,
|
|
subgroup = subgroup,
|
|
online = online,
|
|
index = i
|
|
})
|
|
end
|
|
end
|
|
|
|
-- Sort by subgroup, then by name
|
|
table.sort(roster, function(a, b)
|
|
if a.subgroup ~= b.subgroup then
|
|
return a.subgroup < b.subgroup
|
|
end
|
|
return a.name < b.name
|
|
end)
|
|
|
|
return roster
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Pill Counter Calculations
|
|
-------------------------------------------------------------------------------
|
|
local function calculatePillCounts()
|
|
local numRaid = GetNumRaidMembers()
|
|
local halfCount = math.floor(numRaid / 2)
|
|
local awkwardCount = numRaid - (halfCount * 2) -- 0 or 1
|
|
|
|
-- Count current assignments
|
|
local redAssigned = 0
|
|
local blueAssigned = 0
|
|
|
|
for _, player in ipairs(raidRoster) do
|
|
local assignment = playerAssignments[player.name]
|
|
if assignment == "red" then
|
|
redAssigned = redAssigned + 1
|
|
elseif assignment == "blue" then
|
|
blueAssigned = blueAssigned + 1
|
|
end
|
|
end
|
|
|
|
-- Calculate remaining pills
|
|
local redRemaining = halfCount - redAssigned
|
|
local blueRemaining = halfCount - blueAssigned
|
|
|
|
-- Handle overflow into awkward
|
|
local awkwardUsed = 0
|
|
if redRemaining < 0 then
|
|
awkwardUsed = awkwardUsed - redRemaining
|
|
redRemaining = 0
|
|
end
|
|
if blueRemaining < 0 then
|
|
awkwardUsed = awkwardUsed - blueRemaining
|
|
blueRemaining = 0
|
|
end
|
|
|
|
local awkwardRemaining = awkwardCount - awkwardUsed
|
|
if awkwardRemaining < 0 then awkwardRemaining = 0 end
|
|
|
|
return {
|
|
redTotal = halfCount,
|
|
blueTotal = halfCount,
|
|
awkwardTotal = awkwardCount,
|
|
redRemaining = redRemaining,
|
|
blueRemaining = blueRemaining,
|
|
awkwardRemaining = awkwardRemaining,
|
|
redAssigned = redAssigned,
|
|
blueAssigned = blueAssigned
|
|
}
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- UI Helper Functions
|
|
-------------------------------------------------------------------------------
|
|
local function getClassColor(class)
|
|
if class and BC:GetHexColor(class) then
|
|
return BC:GetHexColor(class)
|
|
end
|
|
return "ffffff"
|
|
end
|
|
|
|
local function createPillIndicator(parent, color, x, y, name)
|
|
local frame = CreateFrame("Frame", name, parent)
|
|
frame:SetWidth(80)
|
|
frame:SetHeight(24)
|
|
frame:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y)
|
|
|
|
-- Count text
|
|
frame.count = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.count:SetPoint("LEFT", 4, 0)
|
|
frame.count:SetText("0")
|
|
frame.count:SetTextColor(1, 1, 1)
|
|
|
|
return frame
|
|
end
|
|
|
|
-- Check if a color can be assigned (has remaining pills)
|
|
local function canAssignColor(colorType)
|
|
local counts = calculatePillCounts()
|
|
|
|
if colorType == "red" then
|
|
-- Can assign red if red pills remain, or if awkward remains and red is full
|
|
return counts.redRemaining > 0 or counts.awkwardRemaining > 0
|
|
elseif colorType == "blue" then
|
|
-- Can assign blue if blue pills remain, or if awkward remains and blue is full
|
|
return counts.blueRemaining > 0 or counts.awkwardRemaining > 0
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
local function createSmallCheckbox(parent, color, onClick)
|
|
local cb = CreateFrame("Button", nil, parent)
|
|
cb:SetWidth(CHECKBOX_SIZE)
|
|
cb:SetHeight(CHECKBOX_SIZE)
|
|
|
|
-- Border (outer colored frame)
|
|
cb.border = cb:CreateTexture(nil, "BORDER")
|
|
cb.border:SetPoint("TOPLEFT", cb, "TOPLEFT", 0, 0)
|
|
cb.border:SetPoint("BOTTOMRIGHT", cb, "BOTTOMRIGHT", 0, 0)
|
|
cb.border:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
cb.border:SetVertexColor(color.r, color.g, color.b, 1)
|
|
|
|
-- Dark background (inner area)
|
|
cb.bg = cb:CreateTexture(nil, "ARTWORK")
|
|
cb.bg:SetPoint("TOPLEFT", cb, "TOPLEFT", 1, -1)
|
|
cb.bg:SetPoint("BOTTOMRIGHT", cb, "BOTTOMRIGHT", -1, 1)
|
|
cb.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
cb.bg:SetVertexColor(0.1, 0.1, 0.1, 0.9)
|
|
|
|
-- Fill (shown when checked)
|
|
cb.fill = cb:CreateTexture(nil, "OVERLAY")
|
|
cb.fill:SetPoint("TOPLEFT", cb, "TOPLEFT", 1, -1)
|
|
cb.fill:SetPoint("BOTTOMRIGHT", cb, "BOTTOMRIGHT", -1, 1)
|
|
cb.fill:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
cb.fill:SetVertexColor(color.r, color.g, color.b, 1)
|
|
cb.fill:Hide()
|
|
|
|
cb.isChecked = false
|
|
cb.color = color
|
|
|
|
cb:SetScript("OnClick", function()
|
|
if onClick then
|
|
onClick(this)
|
|
end
|
|
end)
|
|
|
|
-- Hover effect - slightly brighten the border
|
|
cb:SetScript("OnEnter", function()
|
|
local brighten = 0.3
|
|
local r = math.min(1, this.color.r + brighten)
|
|
local g = math.min(1, this.color.g + brighten)
|
|
local b = math.min(1, this.color.b + brighten)
|
|
this.border:SetVertexColor(r, g, b, 1)
|
|
end)
|
|
|
|
cb:SetScript("OnLeave", function()
|
|
this.border:SetVertexColor(this.color.r, this.color.g, this.color.b, 1)
|
|
end)
|
|
|
|
return cb
|
|
end
|
|
|
|
local function setCheckboxState(cb, checked)
|
|
cb.isChecked = checked
|
|
if checked then
|
|
cb.fill:Show()
|
|
else
|
|
cb.fill:Hide()
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Update Functions
|
|
-------------------------------------------------------------------------------
|
|
local function updatePillIndicators()
|
|
if not matrixFrame then return end
|
|
|
|
local counts = calculatePillCounts()
|
|
|
|
-- Update remaining pills (top)
|
|
matrixFrame.redPillRemaining.count:SetText(tostring(counts.redRemaining))
|
|
matrixFrame.bluePillRemaining.count:SetText(tostring(counts.blueRemaining))
|
|
matrixFrame.awkwardRemaining.count:SetText(tostring(counts.awkwardRemaining))
|
|
|
|
-- Update assigned pills (bottom)
|
|
matrixFrame.redPillAssigned.count:SetText(tostring(counts.redAssigned))
|
|
matrixFrame.bluePillAssigned.count:SetText(tostring(counts.blueAssigned))
|
|
|
|
-- Update button state - only enable when all pills are assigned
|
|
local allAssigned = (counts.redRemaining == 0 and counts.blueRemaining == 0 and counts.awkwardRemaining == 0)
|
|
if allAssigned then
|
|
matrixFrame.assignButton:Enable()
|
|
matrixFrame.assignButton:SetTextColor(1, 1, 1)
|
|
else
|
|
matrixFrame.assignButton:Disable()
|
|
matrixFrame.assignButton:SetTextColor(0.5, 0.5, 0.5)
|
|
end
|
|
end
|
|
|
|
local function updatePlayerFrame(playerFrame, playerData)
|
|
if not playerFrame or not playerData then return end
|
|
|
|
local assignment = playerAssignments[playerData.name]
|
|
|
|
-- Update background color
|
|
if assignment == "red" then
|
|
playerFrame.bg:SetVertexColor(COLOR_RED_BG.r, COLOR_RED_BG.g, COLOR_RED_BG.b, COLOR_RED_BG.a)
|
|
playerFrame.bg:Show()
|
|
elseif assignment == "blue" then
|
|
playerFrame.bg:SetVertexColor(COLOR_BLUE_BG.r, COLOR_BLUE_BG.g, COLOR_BLUE_BG.b, COLOR_BLUE_BG.a)
|
|
playerFrame.bg:Show()
|
|
else
|
|
playerFrame.bg:Hide()
|
|
end
|
|
|
|
-- Update checkbox states
|
|
setCheckboxState(playerFrame.redCB, assignment == "red")
|
|
setCheckboxState(playerFrame.blueCB, assignment == "blue")
|
|
end
|
|
|
|
local function createPlayerFrame(parent, playerData, x, y)
|
|
local frame = CreateFrame("Frame", nil, parent)
|
|
frame:SetWidth(PLAYER_WIDTH)
|
|
frame:SetHeight(PLAYER_HEIGHT)
|
|
frame:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y)
|
|
|
|
-- Background (for assignment highlight)
|
|
frame.bg = frame:CreateTexture(nil, "BACKGROUND")
|
|
frame.bg:SetAllPoints()
|
|
frame.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
frame.bg:Hide()
|
|
|
|
-- Red checkbox
|
|
frame.redCB = createSmallCheckbox(frame, COLOR_RED, function(cb)
|
|
local name = frame.playerName
|
|
if not name then return end
|
|
|
|
local currentAssignment = playerAssignments[name]
|
|
if currentAssignment == "red" then
|
|
-- Unassign
|
|
playerAssignments[name] = nil
|
|
else
|
|
-- Check if we can assign red
|
|
if not canAssignColor("red") then
|
|
return -- No red pills available
|
|
end
|
|
-- Assign to red
|
|
playerAssignments[name] = "red"
|
|
end
|
|
updatePlayerFrame(frame, {name = name})
|
|
updatePillIndicators()
|
|
end)
|
|
frame.redCB:SetPoint("LEFT", 2, 0)
|
|
|
|
-- Blue checkbox
|
|
frame.blueCB = createSmallCheckbox(frame, COLOR_BLUE, function(cb)
|
|
local name = frame.playerName
|
|
if not name then return end
|
|
|
|
local currentAssignment = playerAssignments[name]
|
|
if currentAssignment == "blue" then
|
|
-- Unassign
|
|
playerAssignments[name] = nil
|
|
else
|
|
-- Check if we can assign blue
|
|
if not canAssignColor("blue") then
|
|
return -- No blue pills available
|
|
end
|
|
-- Assign to blue
|
|
playerAssignments[name] = "blue"
|
|
end
|
|
updatePlayerFrame(frame, {name = name})
|
|
updatePillIndicators()
|
|
end)
|
|
frame.blueCB:SetPoint("LEFT", frame.redCB, "RIGHT", 3, 0)
|
|
|
|
-- Player name
|
|
frame.nameText = frame:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.nameText:SetPoint("LEFT", frame.blueCB, "RIGHT", 4, 0)
|
|
frame.nameText:SetWidth(PLAYER_WIDTH - 30)
|
|
frame.nameText:SetJustifyH("LEFT")
|
|
frame.nameText:SetText("")
|
|
|
|
frame.playerName = nil
|
|
|
|
return frame
|
|
end
|
|
|
|
local function createGroupHeader(parent, groupNum, x, y)
|
|
local header = CreateFrame("Frame", nil, parent)
|
|
header:SetWidth(PLAYER_WIDTH)
|
|
header:SetHeight(GROUP_HEADER_HEIGHT)
|
|
header:SetPoint("TOPLEFT", parent, "TOPLEFT", x, y)
|
|
|
|
-- Background
|
|
header.bg = header:CreateTexture(nil, "BACKGROUND")
|
|
header.bg:SetAllPoints()
|
|
header.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
header.bg:SetVertexColor(0.3, 0.3, 0.3, 0.5)
|
|
|
|
-- Text
|
|
header.text = header:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
header.text:SetPoint("LEFT", 4, 0)
|
|
header.text:SetText("Group " .. groupNum)
|
|
header.text:SetTextColor(1, 0.82, 0) -- Gold
|
|
|
|
return header
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Main UI Creation
|
|
-------------------------------------------------------------------------------
|
|
local function createMatrixFrame()
|
|
if matrixFrame then
|
|
return matrixFrame
|
|
end
|
|
|
|
-- Main frame
|
|
local frame = CreateFrame("Frame", "ShootyMatrixFrame", UIParent)
|
|
frame:SetWidth(FRAME_WIDTH)
|
|
frame:SetHeight(FRAME_HEIGHT)
|
|
frame:SetPoint("CENTER", UIParent, "CENTER", 0, 0)
|
|
frame:SetFrameStrata("DIALOG")
|
|
frame:SetMovable(true)
|
|
frame:EnableMouse(true)
|
|
frame:RegisterForDrag("LeftButton")
|
|
frame:SetScript("OnDragStart", function() this:StartMoving() end)
|
|
frame:SetScript("OnDragStop", function() this:StopMovingOrSizing() end)
|
|
frame:Hide()
|
|
|
|
-- Backdrop
|
|
frame:SetBackdrop({
|
|
bgFile = "Interface\\Tooltips\\UI-Tooltip-Background",
|
|
edgeFile = "Interface\\Tooltips\\UI-Tooltip-Border",
|
|
tile = true,
|
|
tileSize = 16,
|
|
edgeSize = 16,
|
|
insets = {left = 4, right = 4, top = 4, bottom = 4}
|
|
})
|
|
frame:SetBackdropColor(0.05, 0.05, 0.05, 0.95)
|
|
frame:SetBackdropBorderColor(0.4, 0.4, 0.4, 1)
|
|
|
|
-- Title bar
|
|
frame.titleBar = CreateFrame("Frame", nil, frame)
|
|
frame.titleBar:SetHeight(24)
|
|
frame.titleBar:SetPoint("TOPLEFT", frame, "TOPLEFT", 4, -4)
|
|
frame.titleBar:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -4, -4)
|
|
|
|
frame.titleBar.bg = frame.titleBar:CreateTexture(nil, "BACKGROUND")
|
|
frame.titleBar.bg:SetAllPoints()
|
|
frame.titleBar.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
frame.titleBar.bg:SetVertexColor(0.15, 0.15, 0.15, 0.9)
|
|
|
|
frame.titleText = frame.titleBar:CreateFontString(nil, "OVERLAY", "GameFontNormal")
|
|
frame.titleText:SetPoint("LEFT", 8, 0)
|
|
frame.titleText:SetText("Matrix - Keeper Gnarlmoon Assignment")
|
|
frame.titleText:SetTextColor(1, 0.82, 0) -- Gold
|
|
|
|
-- Close button
|
|
frame.closeBtn = CreateFrame("Button", nil, frame.titleBar, "UIPanelCloseButton")
|
|
frame.closeBtn:SetPoint("TOPRIGHT", frame.titleBar, "TOPRIGHT", 3, 3)
|
|
frame.closeBtn:SetScript("OnClick", function() frame:Hide() end)
|
|
|
|
-- Pill indicators section (top) - "Pills to assign"
|
|
frame.pillSection = CreateFrame("Frame", nil, frame)
|
|
frame.pillSection:SetHeight(50)
|
|
frame.pillSection:SetPoint("TOPLEFT", frame, "TOPLEFT", 8, -32)
|
|
frame.pillSection:SetPoint("TOPRIGHT", frame, "TOPRIGHT", -8, -32)
|
|
|
|
frame.pillSection.bg = frame.pillSection:CreateTexture(nil, "BACKGROUND")
|
|
frame.pillSection.bg:SetAllPoints()
|
|
frame.pillSection.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
frame.pillSection.bg:SetVertexColor(0.1, 0.1, 0.1, 0.7)
|
|
|
|
frame.pillSection.title = frame.pillSection:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.pillSection.title:SetPoint("TOP", 0, -4)
|
|
frame.pillSection.title:SetText("Pills to Distribute")
|
|
frame.pillSection.title:SetTextColor(0.8, 0.8, 0.8)
|
|
|
|
-- Pill indicators
|
|
frame.redPillRemaining = createPillIndicator(frame.pillSection, COLOR_RED, 175, -20, "MatrixRedPillRemaining")
|
|
frame.redPillRemaining.label = frame.redPillRemaining:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.redPillRemaining.label:SetPoint("LEFT", frame.redPillRemaining.count, "RIGHT", 4, 0)
|
|
frame.redPillRemaining.label:SetText("Red (Left)")
|
|
frame.redPillRemaining.label:SetTextColor(COLOR_RED.r, COLOR_RED.g, COLOR_RED.b)
|
|
|
|
frame.bluePillRemaining = createPillIndicator(frame.pillSection, COLOR_BLUE, 295, -20, "MatrixBluePillRemaining")
|
|
frame.bluePillRemaining.label = frame.bluePillRemaining:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.bluePillRemaining.label:SetPoint("LEFT", frame.bluePillRemaining.count, "RIGHT", 4, 0)
|
|
frame.bluePillRemaining.label:SetText("Blue (Right)")
|
|
frame.bluePillRemaining.label:SetTextColor(COLOR_BLUE.r, COLOR_BLUE.g, COLOR_BLUE.b)
|
|
|
|
frame.awkwardRemaining = createPillIndicator(frame.pillSection, COLOR_AWKWARD, 425, -20, "MatrixAwkwardRemaining")
|
|
frame.awkwardRemaining.label = frame.awkwardRemaining:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.awkwardRemaining.label:SetPoint("LEFT", frame.awkwardRemaining.count, "RIGHT", 4, 0)
|
|
frame.awkwardRemaining.label:SetText("Awkward")
|
|
frame.awkwardRemaining.label:SetTextColor(COLOR_AWKWARD.r, COLOR_AWKWARD.g, COLOR_AWKWARD.b)
|
|
|
|
-- Player list container (scrollable area)
|
|
frame.playerContainer = CreateFrame("Frame", nil, frame)
|
|
frame.playerContainer:SetPoint("TOPLEFT", frame.pillSection, "BOTTOMLEFT", 0, -8)
|
|
frame.playerContainer:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -8, 80)
|
|
|
|
frame.playerContainer.bg = frame.playerContainer:CreateTexture(nil, "BACKGROUND")
|
|
frame.playerContainer.bg:SetAllPoints()
|
|
frame.playerContainer.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
frame.playerContainer.bg:SetVertexColor(0.08, 0.08, 0.08, 0.5)
|
|
|
|
-- Assigned section (bottom) - "Pills taken"
|
|
frame.assignedSection = CreateFrame("Frame", nil, frame)
|
|
frame.assignedSection:SetHeight(40)
|
|
frame.assignedSection:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 8, 36)
|
|
frame.assignedSection:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -8, 36)
|
|
|
|
frame.assignedSection.bg = frame.assignedSection:CreateTexture(nil, "BACKGROUND")
|
|
frame.assignedSection.bg:SetAllPoints()
|
|
frame.assignedSection.bg:SetTexture("Interface\\BUTTONS\\WHITE8X8")
|
|
frame.assignedSection.bg:SetVertexColor(0.1, 0.1, 0.1, 0.7)
|
|
|
|
frame.assignedSection.title = frame.assignedSection:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.assignedSection.title:SetPoint("TOP", 0, -4)
|
|
frame.assignedSection.title:SetText("Pills Taken")
|
|
frame.assignedSection.title:SetTextColor(0.8, 0.8, 0.8)
|
|
|
|
frame.redPillAssigned = createPillIndicator(frame.assignedSection, COLOR_RED, 220, -18, "MatrixRedPillAssigned")
|
|
frame.redPillAssigned.label = frame.redPillAssigned:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.redPillAssigned.label:SetPoint("LEFT", frame.redPillAssigned.count, "RIGHT", 4, 0)
|
|
frame.redPillAssigned.label:SetText("Red")
|
|
frame.redPillAssigned.label:SetTextColor(COLOR_RED.r, COLOR_RED.g, COLOR_RED.b)
|
|
|
|
frame.bluePillAssigned = createPillIndicator(frame.assignedSection, COLOR_BLUE, 360, -18, "MatrixBluePillAssigned")
|
|
frame.bluePillAssigned.label = frame.bluePillAssigned:CreateFontString(nil, "OVERLAY", "GameFontNormalSmall")
|
|
frame.bluePillAssigned.label:SetPoint("LEFT", frame.bluePillAssigned.count, "RIGHT", 4, 0)
|
|
frame.bluePillAssigned.label:SetText("Blue")
|
|
frame.bluePillAssigned.label:SetTextColor(COLOR_BLUE.r, COLOR_BLUE.g, COLOR_BLUE.b)
|
|
|
|
-- Reset button
|
|
frame.resetButton = CreateFrame("Button", "MatrixResetButton", frame, "UIPanelButtonTemplate")
|
|
frame.resetButton:SetWidth(80)
|
|
frame.resetButton:SetHeight(24)
|
|
frame.resetButton:SetPoint("BOTTOMLEFT", frame, "BOTTOMLEFT", 80, 8)
|
|
frame.resetButton:SetText("Reset")
|
|
frame.resetButton:SetScript("OnClick", function()
|
|
sepgp_matrix:ResetAssignments()
|
|
end)
|
|
|
|
-- Assign button
|
|
frame.assignButton = CreateFrame("Button", "MatrixAssignButton", frame, "UIPanelButtonTemplate")
|
|
frame.assignButton:SetWidth(140)
|
|
frame.assignButton:SetHeight(24)
|
|
frame.assignButton:SetPoint("BOTTOMRIGHT", frame, "BOTTOMRIGHT", -80, 8)
|
|
frame.assignButton:SetText("Announce Teams")
|
|
frame.assignButton:Disable()
|
|
frame.assignButton:SetScript("OnClick", function()
|
|
sepgp_matrix:AnnounceTeams()
|
|
end)
|
|
|
|
-- Make escapable
|
|
sepgp:make_escable("ShootyMatrixFrame", "add")
|
|
|
|
matrixFrame = frame
|
|
return frame
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Refresh Display
|
|
-------------------------------------------------------------------------------
|
|
local function refreshPlayerList()
|
|
if not matrixFrame then return end
|
|
if isUpdating then return end
|
|
isUpdating = true
|
|
|
|
-- Hide all existing player frames
|
|
for _, pf in pairs(playerFrames) do
|
|
if pf and pf.Hide then
|
|
pf:Hide()
|
|
end
|
|
end
|
|
|
|
-- Get current roster
|
|
raidRoster = buildRaidRoster()
|
|
|
|
-- Clean up assignments for players no longer in raid
|
|
local rosterLookup = {}
|
|
for _, player in ipairs(raidRoster) do
|
|
rosterLookup[player.name] = true
|
|
end
|
|
|
|
for name, _ in pairs(playerAssignments) do
|
|
if not rosterLookup[name] then
|
|
playerAssignments[name] = nil
|
|
end
|
|
end
|
|
|
|
-- Create player frames organized by group
|
|
local groups = {}
|
|
for i = 1, 8 do
|
|
groups[i] = {}
|
|
end
|
|
|
|
for _, player in ipairs(raidRoster) do
|
|
local g = player.subgroup
|
|
if g and g >= 1 and g <= 8 then
|
|
table.insert(groups[g], player)
|
|
end
|
|
end
|
|
|
|
-- Layout: 4 columns, 2 groups per column
|
|
local COLUMN_WIDTH = 175
|
|
local START_Y = -8
|
|
local GROUP_SPACING = 4
|
|
|
|
local playerIndex = 0
|
|
|
|
for col = 1, 4 do
|
|
local x = (col - 1) * COLUMN_WIDTH + 8
|
|
local y = START_Y
|
|
|
|
local startGroup = (col - 1) * 2 + 1
|
|
local endGroup = col * 2
|
|
|
|
for groupNum = startGroup, endGroup do
|
|
local groupPlayers = groups[groupNum]
|
|
|
|
if groupPlayers and table.getn(groupPlayers) > 0 then
|
|
-- Create group header
|
|
local headerKey = "header_" .. groupNum
|
|
if not playerFrames[headerKey] then
|
|
playerFrames[headerKey] = createGroupHeader(matrixFrame.playerContainer, groupNum, x, y)
|
|
else
|
|
playerFrames[headerKey]:SetPoint("TOPLEFT", matrixFrame.playerContainer, "TOPLEFT", x, y)
|
|
end
|
|
playerFrames[headerKey].text:SetText("Group " .. groupNum)
|
|
playerFrames[headerKey]:Show()
|
|
|
|
y = y - GROUP_HEADER_HEIGHT
|
|
|
|
-- Create player frames
|
|
for _, player in ipairs(groupPlayers) do
|
|
playerIndex = playerIndex + 1
|
|
local key = "player_" .. playerIndex
|
|
|
|
if not playerFrames[key] then
|
|
playerFrames[key] = createPlayerFrame(matrixFrame.playerContainer, player, x, y)
|
|
else
|
|
playerFrames[key]:SetPoint("TOPLEFT", matrixFrame.playerContainer, "TOPLEFT", x, y)
|
|
end
|
|
|
|
local pf = playerFrames[key]
|
|
pf.playerName = player.name
|
|
|
|
-- Set name with class color
|
|
local colorHex = getClassColor(player.class)
|
|
pf.nameText:SetText("|cff" .. colorHex .. player.name .. "|r")
|
|
|
|
-- Update assignment state
|
|
updatePlayerFrame(pf, player)
|
|
pf:Show()
|
|
|
|
y = y - PLAYER_HEIGHT
|
|
end
|
|
|
|
y = y - GROUP_SPACING
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Update pill indicators
|
|
updatePillIndicators()
|
|
|
|
isUpdating = false
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Announce Teams
|
|
-------------------------------------------------------------------------------
|
|
function sepgp_matrix:AnnounceTeams()
|
|
local redTeam = {}
|
|
local blueTeam = {}
|
|
|
|
for _, player in ipairs(raidRoster) do
|
|
local assignment = playerAssignments[player.name]
|
|
if assignment == "red" then
|
|
table.insert(redTeam, {name = player.name, class = player.class})
|
|
elseif assignment == "blue" then
|
|
table.insert(blueTeam, {name = player.name, class = player.class})
|
|
end
|
|
end
|
|
|
|
-- Sort alphabetically
|
|
table.sort(redTeam, function(a, b) return a.name < b.name end)
|
|
table.sort(blueTeam, function(a, b) return a.name < b.name end)
|
|
|
|
-- Build message strings with class colors
|
|
local redNames = {}
|
|
for _, p in ipairs(redTeam) do
|
|
local colorHex = getClassColor(p.class)
|
|
table.insert(redNames, "|cff" .. colorHex .. p.name .. "|r")
|
|
end
|
|
|
|
local blueNames = {}
|
|
for _, p in ipairs(blueTeam) do
|
|
local colorHex = getClassColor(p.class)
|
|
table.insert(blueNames, "|cff" .. colorHex .. p.name .. "|r")
|
|
end
|
|
|
|
-- Send messages
|
|
local channel = "RAID"
|
|
if IsRaidLeader() or IsRaidOfficer() then
|
|
channel = "RAID_WARNING"
|
|
end
|
|
|
|
-- Helper function to send names in chunks of 9
|
|
local NAMES_PER_MESSAGE = 9
|
|
local function sendTeamMessages(names, teamLabel, teamColor)
|
|
local totalNames = table.getn(names)
|
|
if totalNames == 0 then return end
|
|
|
|
local chunk = {}
|
|
for i, name in ipairs(names) do
|
|
table.insert(chunk, name)
|
|
if table.getn(chunk) == NAMES_PER_MESSAGE or i == totalNames then
|
|
local msg = teamColor .. teamLabel .. "|r: " .. table.concat(chunk, ", ")
|
|
SendChatMessage(msg, channel)
|
|
chunk = {}
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Red team announcement
|
|
sendTeamMessages(redNames, "RED TEAM (Left)", "|cffff3333")
|
|
|
|
-- Empty line separator (send a simple divider)
|
|
SendChatMessage("---", channel)
|
|
|
|
-- Blue team announcement
|
|
sendTeamMessages(blueNames, "BLUE TEAM (Right)", "|cff3366ff")
|
|
|
|
-- Also print locally
|
|
sepgp:defaultPrint("Matrix teams have been announced!")
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Reset Assignments
|
|
-------------------------------------------------------------------------------
|
|
function sepgp_matrix:ResetAssignments()
|
|
-- Clear all assignments
|
|
for name, _ in pairs(playerAssignments) do
|
|
playerAssignments[name] = nil
|
|
end
|
|
|
|
-- Refresh the display
|
|
refreshPlayerList()
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Toggle Window
|
|
-------------------------------------------------------------------------------
|
|
function sepgp_matrix:Toggle()
|
|
local canUse, errorMsg = canUseMatrix()
|
|
|
|
if not canUse then
|
|
sepgp:defaultPrint(errorMsg)
|
|
return
|
|
end
|
|
|
|
if not matrixFrame then
|
|
createMatrixFrame()
|
|
end
|
|
|
|
if matrixFrame:IsVisible() then
|
|
matrixFrame:Hide()
|
|
else
|
|
refreshPlayerList()
|
|
matrixFrame:Show()
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Event Handlers
|
|
-------------------------------------------------------------------------------
|
|
function sepgp_matrix:OnEnable()
|
|
self:RegisterEvent("RAID_ROSTER_UPDATE", "OnRaidRosterUpdate")
|
|
self:RegisterEvent("PARTY_MEMBERS_CHANGED", "OnRaidRosterUpdate")
|
|
end
|
|
|
|
function sepgp_matrix:OnDisable()
|
|
if matrixFrame then
|
|
matrixFrame:Hide()
|
|
end
|
|
end
|
|
|
|
function sepgp_matrix:OnRaidRosterUpdate()
|
|
if matrixFrame and matrixFrame:IsVisible() then
|
|
refreshPlayerList()
|
|
end
|
|
end
|
|
|
|
-------------------------------------------------------------------------------
|
|
-- Slash Command Registration
|
|
-------------------------------------------------------------------------------
|
|
SLASH_MATRIX1 = "/matrix"
|
|
SlashCmdList["MATRIX"] = function(msg)
|
|
sepgp_matrix:Toggle()
|
|
end
|