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.
1342 lines
52 KiB
1342 lines
52 KiB
local MDT = MDT
|
|
local db
|
|
local tonumber,tinsert,slen,pairs,ipairs,tostring,next,type,sformat,twipe,max,tremove,DrawLine = tonumber,table.insert,string.len,pairs,ipairs,tostring,next,type,string.format,table.wipe,math.max,table.remove,DrawLine
|
|
local L = MDT.L
|
|
local blips = {}
|
|
local preset
|
|
local selectedGreen = {34/255,139/255,34/255,0.7}
|
|
local patrolColor = {0,0.5,1,0.8}
|
|
local corruptedColor = {1,0,1,0.8}
|
|
|
|
function MDT:GetDungeonEnemyBlips()
|
|
return blips
|
|
end
|
|
|
|
MDT.reapingStatic = {
|
|
["148716"] = {
|
|
["name"] = L["Risen Soul"],
|
|
["iconTexture"] = "Interface\\Icons\\Ability_warlock_soulsiphon",
|
|
["abilities"] = {},
|
|
["npcId"] = 148716,
|
|
["outline"] = { 1.02, 0, 2.04, 1 }
|
|
},
|
|
["148893"] = {
|
|
["name"] = L["Tormented Soul"],
|
|
["iconTexture"] = "Interface\\Icons\\spell_shadow_soulleech_1",
|
|
["abilities"] = {},
|
|
["npcId"] = 148893,
|
|
["outline"] = { 0, 2.04, 1.02, 1 }
|
|
},
|
|
["148894"] = {
|
|
["name"] = L["Lost Soul"],
|
|
["iconTexture"] = "Interface\\Icons\\ability_warlock_improvedsoulleech",
|
|
["abilities"] = {},
|
|
["npcId"] = 148894,
|
|
["outline"] = { 2.04, 0, 2.04, 1 }
|
|
},
|
|
}
|
|
|
|
--From http://wow.gamepedia.com/UI_coordinates
|
|
function MDT:DoFramesOverlap(frameA, frameB, offset)
|
|
if not frameA or not frameB then return end
|
|
offset = offset or 0
|
|
--frameA = frameA.texture_Background
|
|
--frameB = frameB.texture_Background
|
|
|
|
local sA, sB = frameA:GetEffectiveScale(), frameB:GetEffectiveScale();
|
|
if not sA or not sB then return end
|
|
|
|
local frameALeft = frameA:GetLeft()-offset
|
|
local frameARight = frameA:GetRight()+offset
|
|
local frameABottom = frameA:GetBottom()-offset
|
|
local frameATop = frameA:GetTop()+offset
|
|
|
|
local frameBLeft = frameB:GetLeft()
|
|
local frameBRight = frameB:GetRight()
|
|
local frameBBottom = frameB:GetBottom()
|
|
local frameBTop = frameB:GetTop()
|
|
|
|
if not frameALeft or not frameARight or not frameABottom or not frameATop then return end
|
|
if not frameBLeft or not frameBRight or not frameBBottom or not frameBTop then return end
|
|
|
|
return ((frameALeft*sA) < (frameBRight*sB))
|
|
and ((frameBLeft*sB) < (frameARight*sA))
|
|
and ((frameABottom*sA) < (frameBTop*sB))
|
|
and ((frameBBottom*sB) < (frameATop*sA));
|
|
end
|
|
|
|
|
|
MDTDungeonEnemyMixin = {};
|
|
|
|
local defaultSizes = {
|
|
["texture_Background"] = 20,
|
|
["texture_Portrait"] = 15,
|
|
["texture_MouseHighlight"] = 20,
|
|
["texture_SelectedHighlight"] = 20,
|
|
["texture_Reaping"] = 8,
|
|
["texture_Dragon"] = 26,
|
|
["texture_Indicator"] = 20,
|
|
["texture_PullIndicator"] = 23,
|
|
["texture_DragDown"] = 8,
|
|
["texture_DragLeft"] = 8,
|
|
["texture_DragRight"] = 8,
|
|
["texture_DragUp"] = 8,
|
|
}
|
|
|
|
function MDTDungeonEnemyMixin:updateSizes(scale)
|
|
for tex,size in pairs(defaultSizes) do
|
|
self[tex]:SetSize(size*self.normalScale*scale,size*self.normalScale*scale)
|
|
end
|
|
end
|
|
|
|
function MDTDungeonEnemyMixin:OnEnter()
|
|
self:updateSizes(1.2)
|
|
self:SetFrameLevel(self:GetFrameLevel()+5)
|
|
self:DisplayPatrol(true)
|
|
MDT:DisplayBlipTooltip(self,true)
|
|
if self.data.corrupted then
|
|
--self.texture_DragDown:Show()
|
|
--self.texture_DragLeft:Show()
|
|
--self.texture_DragRight:Show()
|
|
--self.texture_DragUp:Show()
|
|
if not self.selected then
|
|
local _,active = MDT.poi_framePools:GetPool("VignettePinTemplate"):EnumerateActive()
|
|
for poiFrame,_ in pairs(active) do
|
|
if poiFrame.spireIndex and poiFrame.npcId == self.data.id then
|
|
poiFrame.HighlightTexture:Show()
|
|
self.spireFrame = poiFrame
|
|
self.animatedLine = MDT:ShowAnimatedLine(MDT.main_frame.mapPanelFrame,self.spireFrame,self,nil,nil,nil,nil,nil,self.selected,self.animatedLine)
|
|
self.spireFrame.animatedLine = self.animatedLine
|
|
break
|
|
end
|
|
end
|
|
local connectedDoor = MDT:FindConnectedDoor(self.data.id)
|
|
if connectedDoor then
|
|
self.animatedLine = MDT:ShowAnimatedLine(MDT.main_frame.mapPanelFrame,connectedDoor,self,nil,nil,nil,nil,nil,self.selected,self.animatedLine)
|
|
end
|
|
end
|
|
end
|
|
if not db.devMode then
|
|
self.fontstring_Text1:SetText(MDT:IsCurrentPresetTeeming() and self.data.teemingCount or self.data.count)
|
|
if not self.clone.g then
|
|
self.fontstring_Text1:Show()
|
|
return
|
|
end
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.g == self.clone.g then
|
|
blip.fontstring_Text1:SetText(MDT:IsCurrentPresetTeeming() and blip.data.teemingCount or blip.data.count)
|
|
blip.fontstring_Text1:Show()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDTDungeonEnemyMixin:OnLeave()
|
|
self:updateSizes(1)
|
|
self:SetFrameLevel(self:GetFrameLevel()-5)
|
|
if db.devMode then
|
|
if not self.devSelected then self:DisplayPatrol(false) end
|
|
else
|
|
self:DisplayPatrol(false)
|
|
end
|
|
MDT:DisplayBlipTooltip(self,false)
|
|
if self.data.corrupted then
|
|
self.texture_DragDown:Hide()
|
|
self.texture_DragLeft:Hide()
|
|
self.texture_DragRight:Hide()
|
|
self.texture_DragUp:Hide()
|
|
local _,active = MDT.poi_framePools:GetPool("VignettePinTemplate"):EnumerateActive()
|
|
for poiFrame,_ in pairs(active) do
|
|
if poiFrame.spireIndex and poiFrame.npcId == self.data.id then
|
|
poiFrame.HighlightTexture:Hide()
|
|
break
|
|
end
|
|
end
|
|
if not self.selected then
|
|
MDT:HideAnimatedLine(self.animatedLine)
|
|
end
|
|
end
|
|
if not db.devMode then
|
|
if not self.clone.g then
|
|
self.fontstring_Text1:Hide()
|
|
return
|
|
end
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.g == self.clone.g then
|
|
blip.fontstring_Text1:Hide()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function setUpMouseHandlers(self)
|
|
self:SetScript("OnMouseDown",function(self, button)
|
|
|
|
end)
|
|
local tempPulls
|
|
self:SetScript("OnDragStart", function()
|
|
local x,y,scale
|
|
preset = MDT:GetCurrentPreset()
|
|
tempPulls = MDT:DeepCopy(preset.value.pulls)
|
|
local targetPull
|
|
local _, _, _, blipX, blipY = self:GetPoint()
|
|
self:SetScript("OnUpdate",function()
|
|
local nx,ny = MDT:GetCursorPosition()
|
|
if x~=nx or y~=ny then
|
|
x,y = nx,ny
|
|
--find closest pull and measure distance
|
|
local pullIdx,centerX,centerY = MDT:FindClosestPull(x,y)
|
|
if not centerX then return end
|
|
local distBlip = (centerX-blipX)^2+(centerY-blipY)^2
|
|
local distCursor = (centerX-x)^2+(centerY-y)^2
|
|
local isClose = distCursor<1/3*distBlip or distBlip < 150
|
|
if not isClose then
|
|
targetPull = nil
|
|
MDT:DungeonEnemies_AddOrRemoveBlipToCurrentPull(self, false, IsControlKeyDown(),tempPulls,nil,true)
|
|
MDT:DungeonEnemies_UpdateSelected(MDT:GetCurrentPull(),tempPulls)
|
|
elseif pullIdx~=targetPull then
|
|
targetPull = pullIdx
|
|
MDT:DungeonEnemies_AddOrRemoveBlipToCurrentPull(self, true, IsControlKeyDown(),tempPulls,pullIdx,true)
|
|
MDT:DungeonEnemies_UpdateSelected(MDT:GetCurrentPull(),tempPulls)
|
|
end
|
|
end
|
|
end)
|
|
end)
|
|
self:SetScript("OnDragStop", function()
|
|
self:SetScript("OnUpdate",nil)
|
|
preset.value.pulls = tempPulls
|
|
MDT:DungeonEnemies_UpdateSelected(MDT:GetCurrentPull(),tempPulls)
|
|
MDT:ReloadPullButtons()
|
|
if MDT.liveSessionActive and MDT:GetCurrentPreset().uid == MDT.livePresetUID then
|
|
MDT:LiveSession_SendPulls(MDT:GetPulls())
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function setUpMouseHandlersAwakened(self,clone,scale,riftOffsets)
|
|
local xOffset,yOffset
|
|
local oldX,oldY
|
|
self:SetScript("OnMouseDown",function(self, button)
|
|
if button == "LeftButton" then
|
|
riftOffsets = MDT:GetRiftOffsets()
|
|
local x,y = MDT:GetCursorPosition()
|
|
local scale = MDT:GetScale()
|
|
x = x*(1/scale)
|
|
y = y*(1/scale)
|
|
oldX = riftOffsets and riftOffsets[self.data.id] and riftOffsets[self.data.id].x or clone.x
|
|
oldY = riftOffsets and riftOffsets[self.data.id] and riftOffsets[self.data.id].y or clone.y
|
|
xOffset = x-oldX
|
|
yOffset = y-oldY
|
|
end
|
|
end)
|
|
self:SetScript("OnDragStart", function()
|
|
self:StartMoving()
|
|
MDT.draggedBlip = self
|
|
local _,activeDoors = MDT.poi_framePools:GetPool("MapLinkPinTemplate"):EnumerateActive()
|
|
riftOffsets = MDT:GetRiftOffsets()
|
|
self:SetScript("OnUpdate",function()
|
|
for poiFrame,_ in pairs(activeDoors) do
|
|
if MDT:DoFramesOverlap(self,poiFrame,-10) then
|
|
poiFrame.HighlightTexture:Show()
|
|
else
|
|
poiFrame.HighlightTexture:Hide()
|
|
end
|
|
end
|
|
--reposition animated line
|
|
local x,y = MDT:GetCursorPosition()
|
|
local scale = MDT:GetScale()
|
|
x = x*(1/scale)
|
|
y = y*(1/scale)
|
|
x = x-xOffset
|
|
y = y-yOffset
|
|
if x ~= self.adjustedX or y~= self.adjustedY then
|
|
local sizex,sizey = MDT:GetDefaultMapPanelSize()
|
|
x = x<=0 and 0 or x>=sizex and sizex or x
|
|
y = y>=0 and 0 or y<=(-1)*sizey and (-1)*sizey or y
|
|
self.adjustedX = x
|
|
self.adjustedY = y
|
|
local connectedDoor = MDT:FindConnectedDoor(self.data.id)
|
|
self.animatedLine = MDT:ShowAnimatedLine(MDT.main_frame.mapPanelFrame,connectedDoor or self.spireFrame ,self,nil,nil,nil,nil,nil,self.selected,self.animatedLine)
|
|
riftOffsets[self.data.id] = riftOffsets[self.data.id] or {}
|
|
riftOffsets[self.data.id].x = x
|
|
riftOffsets[self.data.id].y = y
|
|
self:ClearAllPoints()
|
|
self:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",x*scale,y*scale)
|
|
end
|
|
end)
|
|
end)
|
|
self:SetScript("OnDragStop", function()
|
|
MDT.draggedBlip = nil
|
|
riftOffsets = MDT:GetRiftOffsets()
|
|
self:StopMovingOrSizing()
|
|
self:SetScript("OnUpdate",nil)
|
|
self:ClearAllPoints()
|
|
self:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",self.adjustedX*scale,self.adjustedY*scale)
|
|
--dragged ontop of door
|
|
--find doors,check overlap,break,swap sublevel,change poi sublevel
|
|
local _,active = MDT.poi_framePools:GetPool("MapLinkPinTemplate"):EnumerateActive()
|
|
for poiFrame,_ in pairs(active) do
|
|
if MDT:DoFramesOverlap(self,poiFrame,-10) then
|
|
riftOffsets[self.data.id].sublevel = poiFrame.target
|
|
riftOffsets[self.data.id].homeSublevel = self.clone.sublevel or 1
|
|
riftOffsets[self.data.id].connections = riftOffsets[self.data.id].connections or {}
|
|
local c = riftOffsets[self.data.id].connections
|
|
local shouldAdd = true
|
|
for idx,value in ipairs(c) do
|
|
if value.source == poiFrame.poi.target then
|
|
tremove(c,idx)
|
|
shouldAdd = false
|
|
break
|
|
end
|
|
end
|
|
if shouldAdd then tinsert(c,{ connectionIndex=poiFrame.poi.connectionIndex, source= MDT:GetCurrentSubLevel()+0, target=poiFrame.poi.target}) end
|
|
if riftOffsets[self.data.id].sublevel == (self.clone.sublevel or 1)then
|
|
riftOffsets[self.data.id].sublevel = nil
|
|
riftOffsets[self.data.id].homeSublevel = nil
|
|
end
|
|
--zoom out
|
|
--move frame
|
|
poiFrame:Click()
|
|
break
|
|
end
|
|
end
|
|
if MDT.liveSessionActive and MDT:GetCurrentPreset().uid == MDT.livePresetUID then
|
|
MDT:LiveSession_SendCorruptedPositions(preset.value.riftOffsets)
|
|
end
|
|
end)
|
|
end
|
|
|
|
function MDTDungeonEnemyMixin:OnClick(button, down)
|
|
|
|
if button == "LeftButton" then
|
|
if IsShiftKeyDown() then
|
|
local newPullIdx = MDT:GetCurrentPull() + 1
|
|
MDT:PresetsAddPull(newPullIdx)
|
|
MDT:GetCurrentPreset().value.selection = { newPullIdx}
|
|
MDT:ReloadPullButtons()
|
|
MDT:SetSelectionToPull(newPullIdx)
|
|
local _
|
|
MDT:ColorAllPulls(_, newPullIdx)
|
|
--if MDT:GetPullsNum() == 2 then MDT:SetAutomaticColor(1) end
|
|
end
|
|
MDT:DungeonEnemies_AddOrRemoveBlipToCurrentPull(self,not self.selected,IsControlKeyDown())
|
|
MDT:DungeonEnemies_UpdateSelected(MDT:GetCurrentPull())
|
|
MDT:UpdateProgressbar()
|
|
MDT:ReloadPullButtons()
|
|
if MDT.liveSessionActive and MDT:GetCurrentPreset().uid == MDT.livePresetUID then
|
|
MDT:LiveSession_SendPulls(MDT:GetPulls())
|
|
end
|
|
if self.data.corrupted then
|
|
local connectedFrame
|
|
local _,active = MDT.poi_framePools:GetPool("VignettePinTemplate"):EnumerateActive()
|
|
for poiFrame,_ in pairs(active) do
|
|
if poiFrame.spireIndex and poiFrame.npcId and poiFrame.npcId == self.data.id then
|
|
if self.selected then
|
|
poiFrame.Texture:SetAtlas("poi-rift1")
|
|
poiFrame.Texture:SetSize(17*poiFrame.poiScale,17*poiFrame.poiScale)
|
|
poiFrame.HighlightTexture:SetAtlas("poi-rift1")
|
|
poiFrame.HighlightTexture:SetSize(17*poiFrame.poiScale,17*poiFrame.poiScale)
|
|
poiFrame.isSpire = false
|
|
poiFrame.ShowAnim:Play()
|
|
poiFrame.textString:Show()
|
|
else
|
|
poiFrame.Texture:SetSize(16*poiFrame.poiScale,22*poiFrame.poiScale)
|
|
poiFrame.Texture:SetAtlas("poi-nzothpylon")
|
|
poiFrame.HighlightTexture:SetSize(16,22*poiFrame.poiScale,22,22*poiFrame.poiScale)
|
|
poiFrame.HighlightTexture:SetAtlas("poi-nzothpylon")
|
|
poiFrame.isSpire = true
|
|
poiFrame.ShowAnim:Play()
|
|
poiFrame.textString:Hide()
|
|
end
|
|
connectedFrame = poiFrame
|
|
break
|
|
end
|
|
end
|
|
local connectedDoor = MDT:FindConnectedDoor(self.data.id)
|
|
connectedFrame = connectedDoor or connectedFrame
|
|
self.animatedLine = MDT:ShowAnimatedLine(MDT.main_frame.mapPanelFrame,connectedFrame,self,nil,nil,nil,nil,nil,self.selected,self.animatedLine)
|
|
connectedFrame.animatedLine = self.animatedLine
|
|
if MDT.liveSessionActive and MDT:GetCurrentPreset().uid == MDT.livePresetUID then
|
|
MDT:LiveSession_SendCorruptedPositions(preset.value.riftOffsets)
|
|
end
|
|
end
|
|
elseif button == "RightButton" then
|
|
if db.devMode then
|
|
if IsAltKeyDown() then
|
|
tremove(MDT.dungeonEnemies[db.currentDungeonIdx][self.enemyIdx].clones,self.cloneIdx)
|
|
self:Hide()
|
|
else
|
|
self.devSelected = (not self.devSelected) or nil
|
|
self:DisplayPatrol(self.devSelected)
|
|
for blipIdx,blip in pairs(blips) do
|
|
if blip ~= self then
|
|
blip.devSelected = nil
|
|
end
|
|
if blip.devSelected then
|
|
blip.texture_Portrait:SetVertexColor(1,0,0,1)
|
|
else
|
|
blip.texture_Portrait:SetVertexColor(1,1,1,1)
|
|
end
|
|
end
|
|
end
|
|
MDT:UpdateMap()
|
|
else
|
|
MDT:ShowEnemyInfoFrame(self)
|
|
end
|
|
end
|
|
end
|
|
|
|
local patrolPoints = {}
|
|
local patrolLines = {}
|
|
|
|
function MDT:GetPatrolBlips()
|
|
return patrolPoints
|
|
end
|
|
|
|
function MDTDungeonEnemyMixin:DisplayPatrol(shown)
|
|
local scale = MDT:GetScale()
|
|
|
|
--Hide all points/line
|
|
for _,point in pairs(patrolPoints) do point:Hide() end
|
|
for _,line in pairs(patrolLines) do line:Hide() end
|
|
if not shown then return end
|
|
|
|
if self.clone.patrol then
|
|
local firstWaypointBlip
|
|
local oldWaypointBlip
|
|
for patrolIdx,waypoint in ipairs(self.clone.patrol) do
|
|
patrolPoints[patrolIdx] = patrolPoints[patrolIdx] or MDT.main_frame.mapPanelFrame:CreateTexture("MDTDungeonPatrolPoint"..patrolIdx,"BACKGROUND")
|
|
|
|
|
|
patrolPoints[patrolIdx]:SetDrawLayer("OVERLAY", 2)
|
|
patrolPoints[patrolIdx]:SetTexture("Interface\\Worldmap\\X_Mark_64Grey")
|
|
patrolPoints[patrolIdx]:SetSize(4*scale,4*scale)
|
|
patrolPoints[patrolIdx]:SetVertexColor(0,0.2,0.5,0.6)
|
|
patrolPoints[patrolIdx]:ClearAllPoints()
|
|
patrolPoints[patrolIdx]:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",waypoint.x*scale,waypoint.y*scale)
|
|
patrolPoints[patrolIdx].x = waypoint.x
|
|
patrolPoints[patrolIdx].y = waypoint.y
|
|
patrolPoints[patrolIdx]:Show()
|
|
|
|
patrolLines[patrolIdx] = patrolLines[patrolIdx] or MDT.main_frame.mapPanelFrame:CreateTexture("MDTDungeonPatrolLine"..patrolIdx,"BACKGROUND")
|
|
patrolLines[patrolIdx]:SetDrawLayer("OVERLAY", 1)
|
|
patrolLines[patrolIdx]:SetTexture("Interface\\AddOns\\MythicDungeonTools\\Textures\\Square_White")
|
|
patrolLines[patrolIdx]:SetVertexColor(0,0.2,0.5,0.6)
|
|
patrolLines[patrolIdx]:Show()
|
|
|
|
--connect 2 waypoints
|
|
if oldWaypointBlip then
|
|
local startPoint, startRelativeTo, startRelativePoint, startX, startY = patrolPoints[patrolIdx]:GetPoint()
|
|
local endPoint, endRelativeTo, endRelativePoint, endX, endY = oldWaypointBlip:GetPoint()
|
|
DrawLine(patrolLines[patrolIdx], MDT.main_frame.mapPanelTile1, startX, startY, endX, endY, 1*scale, 1,"TOPLEFT")
|
|
patrolLines[patrolIdx]:Show()
|
|
else
|
|
firstWaypointBlip = patrolPoints[patrolIdx]
|
|
end
|
|
oldWaypointBlip = patrolPoints[patrolIdx]
|
|
end
|
|
--connect last 2 waypoints
|
|
if firstWaypointBlip and oldWaypointBlip then
|
|
local startPoint, startRelativeTo, startRelativePoint, startX, startY = firstWaypointBlip:GetPoint()
|
|
local endPoint, endRelativeTo, endRelativePoint, endX, endY = oldWaypointBlip:GetPoint()
|
|
DrawLine(patrolLines[1], MDT.main_frame.mapPanelTile1, startX, startY, endX, endY, 1*scale, 1,"TOPLEFT")
|
|
patrolLines[1]:Show()
|
|
end
|
|
|
|
else
|
|
--find patrol leader if no patrol
|
|
for _,blip in pairs(blips) do
|
|
if blip:IsShown() and blip.clone.g and self.clone.g then
|
|
if blip.clone.g == self.clone.g and blip.clone.patrol then
|
|
blip:DisplayPatrol(shown)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
local ranOnce
|
|
function MDT:DisplayBlipTooltip(blip, shown)
|
|
if not ranOnce then
|
|
--fix elvui skinning
|
|
MDT.tooltip:ClearAllPoints()
|
|
MDT.tooltip:SetPoint("TOPLEFT",UIParent,"BOTTOMRIGHT")
|
|
MDT.tooltip:SetPoint("BOTTOMRIGHT",UIParent,"BOTTOMRIGHT")
|
|
MDT.tooltip:Show()
|
|
MDT.tooltip:Hide()
|
|
ranOnce = true
|
|
end
|
|
|
|
local tooltip = MDT.tooltip
|
|
local data = blip.data
|
|
if shown then
|
|
tooltip.Model:SetCreature(data.id)
|
|
tooltip.String:Show()
|
|
tooltip:Show()
|
|
else
|
|
tooltip.String:Hide()
|
|
tooltip:Hide()
|
|
return
|
|
end
|
|
|
|
local boss = blip.data.isBoss or false
|
|
local health = MDT:CalculateEnemyHealth(boss,data.health,db.currentDifficulty,data.ignoreFortified)
|
|
local group = blip.clone.g and " "..string.format(L["(G %d)"],blip.clone.g) or ""
|
|
--local upstairs = blip.clone.upstairs and CreateTextureMarkup("Interface\\MINIMAP\\MiniMap-PositionArrows", 16, 32, 16, 16, 0, 1, 0, 0.5,0,-50) or ""
|
|
--[[
|
|
function CreateAtlasMarkup(atlasName, height, width, offsetX, offsetY) return ("|A:%s:%d:%d:%d:%d|a"):format( atlasName , height or 0 , width or 0 , offsetX or 0 , offsetY or 0 );end
|
|
]]
|
|
local occurence = (blip.data.isBoss and "") or blip.cloneIdx
|
|
|
|
local text = L[data.name].." "..occurence..group.."\n"..string.format(L["Level %d %s"],data.level,L[data.creatureType]).."\n".. string.format(L["%s HP"],MDT:FormatEnemyHealth(health)).."\n"
|
|
local count = MDT:IsCurrentPresetTeeming() and data.teemingCount or data.count
|
|
text = text ..L["Forces"]..": ".. MDT:FormatEnemyForces(count)
|
|
local reapingText
|
|
if blip.data.reaping and db.MDI.enabled and preset.mdi.beguiling == 13 then
|
|
local reapingIcon = CreateTextureMarkup(MDT.reapingStatic[tostring(blip.data.reaping)].iconTexture, 32, 32, 16, 16, 0, 1, 0, 1,0,0) or ""
|
|
reapingText = L["Reaping"]..": "..reapingIcon.." ".. MDT.reapingStatic[tostring(blip.data.reaping)].name .. "\n"
|
|
end
|
|
if reapingText then text = text .. "\n" .. reapingText end
|
|
text = text .."\n\n["..L["Right click for more info"].."]"
|
|
tooltip.String:SetText(text)
|
|
|
|
tooltip:ClearAllPoints()
|
|
if db.tooltipInCorner then
|
|
tooltip:SetPoint("BOTTOMRIGHT", MDT.main_frame,"BOTTOMRIGHT",0,0)
|
|
tooltip:SetPoint("TOPLEFT", MDT.main_frame,"BOTTOMRIGHT",-tooltip.mySizes.x,tooltip.mySizes.y)
|
|
else
|
|
--check for bottom clipping
|
|
tooltip:ClearAllPoints()
|
|
tooltip:SetPoint("TOPLEFT",blip,"BOTTOMRIGHT",30,0)
|
|
tooltip:SetPoint("BOTTOMRIGHT",blip,"BOTTOMRIGHT",30+tooltip.mySizes.x,-tooltip.mySizes.y)
|
|
local bottomOffset = 0
|
|
local rightOffset = 0
|
|
local tooltipBottom = tooltip:GetBottom()
|
|
local mainFrameBottom = MDT.main_frame:GetBottom()
|
|
if tooltipBottom<mainFrameBottom then
|
|
bottomOffset = tooltip.mySizes.y
|
|
end
|
|
--right side clipping
|
|
local tooltipRight = tooltip:GetRight()
|
|
local mainFrameRight = MDT.main_frame:GetRight()
|
|
if tooltipRight>mainFrameRight then
|
|
rightOffset = -(tooltip.mySizes.x+60)
|
|
end
|
|
|
|
tooltip:SetPoint("TOPLEFT",blip,"BOTTOMRIGHT",30+rightOffset,bottomOffset)
|
|
tooltip:SetPoint("BOTTOMRIGHT",blip,"BOTTOMRIGHT",30+tooltip.mySizes.x+rightOffset,-tooltip.mySizes.y+bottomOffset)
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
function MDT:GetCurrentDevmodeBlip()
|
|
for blipIdx,blip in pairs(blips) do
|
|
if blip.devSelected then
|
|
return blip
|
|
end
|
|
end
|
|
end
|
|
|
|
--make blip movable in devMode and store new position
|
|
local function blipDevModeSetup(blip)
|
|
blip:SetMovable(true)
|
|
blip:RegisterForDrag("LeftButton")
|
|
|
|
local xOffset,yOffset
|
|
blip:SetScript("OnMouseDown",function()
|
|
local x,y = MDT:GetCursorPosition()
|
|
local scale = MDT:GetScale()
|
|
x = x*(1/scale)
|
|
y = y*(1/scale)
|
|
local nx = MDT.dungeonEnemies[db.currentDungeonIdx][blip.enemyIdx].clones[blip.cloneIdx].x
|
|
local ny = MDT.dungeonEnemies[db.currentDungeonIdx][blip.enemyIdx].clones[blip.cloneIdx].y
|
|
xOffset = x-nx
|
|
yOffset = y-ny
|
|
end)
|
|
blip:SetScript("OnDragStart", function()
|
|
if not db.devModeBlipsMovable then return end
|
|
blip:StartMoving()
|
|
end)
|
|
blip:SetScript("OnDragStop", function()
|
|
if not db.devModeBlipsMovable then return end
|
|
local x,y = MDT:GetCursorPosition()
|
|
local scale = MDT:GetScale()
|
|
x = x*(1/scale)
|
|
y = y*(1/scale)
|
|
x = x-xOffset
|
|
y = y-yOffset
|
|
blip:StopMovingOrSizing()
|
|
blip:ClearAllPoints()
|
|
blip:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",x*scale,y*scale)
|
|
MDT.dungeonEnemies[db.currentDungeonIdx][blip.enemyIdx].clones[blip.cloneIdx].x = x
|
|
MDT.dungeonEnemies[db.currentDungeonIdx][blip.enemyIdx].clones[blip.cloneIdx].y = y
|
|
end)
|
|
local groupColors = {
|
|
[1] = {1,0,0,1},
|
|
[2] = {0,1,0,1},
|
|
[3] = {0,0,1,1},
|
|
[4] = {1,0,1,1},
|
|
[5] = {0,1,1,1},
|
|
}
|
|
blip:SetScript("OnMouseWheel", function(self, delta)
|
|
if not db.devModeBlipsScrollable then return end
|
|
if not blip.clone.g then
|
|
local maxGroup = 0
|
|
for _,data in pairs(MDT.dungeonEnemies[db.currentDungeonIdx]) do
|
|
for _,clone in pairs(data.clones) do
|
|
maxGroup = (clone.g and (clone.g>maxGroup)) and clone.g or maxGroup
|
|
end
|
|
end
|
|
if IsControlKeyDown() then
|
|
maxGroup = maxGroup + 1
|
|
end
|
|
blip.clone.g = maxGroup
|
|
else
|
|
blip.clone.g = blip.clone.g + delta
|
|
end
|
|
blip.fontstring_Text1:SetText(blip.clone.g)
|
|
if blip.clone.g then blip.fontstring_Text1:SetTextColor(unpack(groupColors[blip.clone.g%5+1])) end
|
|
end)
|
|
blip.fontstring_Text1:Show()
|
|
blip.fontstring_Text1:SetText(blip.clone.g)
|
|
if blip.clone.g then blip.fontstring_Text1:SetTextColor(unpack(groupColors[blip.clone.g%5+1])) end
|
|
end
|
|
|
|
local emissaryIds = {[155432]=true,[155433]=true,[155434]=true}
|
|
local tormentedIds = {[179891]=true,[179892]=true,[179890]=true,[179446]=true}
|
|
|
|
function MDTDungeonEnemyMixin:SetUp(data,clone)
|
|
local scale = MDT:GetScale()
|
|
self:ClearAllPoints()
|
|
self:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",clone.x*scale,clone.y*scale)
|
|
self.normalScale = data.scale*(data.isBoss and 1.7 or 1)*(MDT.scaleMultiplier[db.currentDungeonIdx] or 1)*scale
|
|
self.normalScale = self.normalScale * 0.6
|
|
self:SetSize(self.normalScale*13,self.normalScale*13)
|
|
self:updateSizes(1)
|
|
self.texture_Portrait:SetDesaturated(false)
|
|
local raise = 4
|
|
if not data.corrupted then
|
|
for k,v in pairs(blips) do
|
|
--only check neighboring blips - saves performance on big maps
|
|
if ((clone.x-v.clone.x)^2+(clone.y-v.clone.y)^2<81) and MDT:DoFramesOverlap(self, v,5) then raise = max(raise,v:GetFrameLevel()+1) end
|
|
end
|
|
end
|
|
self:SetFrameLevel(raise)
|
|
self.fontstring_Text1:SetFontObject("GameFontNormal")
|
|
self.fontstring_Text1:SetFont(self.fontstring_Text1:GetFont(),10*self.normalScale,"OUTLINE")
|
|
self.fontstring_Text1:SetText((clone.isBoss and data.count == 0 and "") or data.count)
|
|
self.texture_MouseHighlight:SetAlpha(0.4)
|
|
self.texture_SelectedHighlight:SetVertexColor(unpack(selectedGreen))
|
|
if data.isBoss then self.texture_Dragon:Show() else self.texture_Dragon:Hide() end
|
|
self.texture_Background:SetVertexColor(1,1,1,1)
|
|
if clone.patrol then self.texture_Background:SetVertexColor(unpack(patrolColor)) end
|
|
self.data = data
|
|
self.clone = clone
|
|
self:Show()
|
|
self:SetScript("OnUpdate",nil)
|
|
self:SetMovable(false)
|
|
--awakened/corrupted adjustments: movable and color and stored position
|
|
if data.corrupted then
|
|
self:SetFrameLevel(15)
|
|
self.texture_Background:SetVertexColor(unpack(corruptedColor))
|
|
self.texture_DragLeft:SetRotation(-1.5708)
|
|
self.texture_DragRight:SetRotation(1.5708)
|
|
self.texture_DragUp:SetRotation(3.14159)
|
|
local riftOffsets = MDT:GetRiftOffsets()
|
|
self.adjustedX = riftOffsets and riftOffsets[self.data.id] and riftOffsets[self.data.id].x or clone.x
|
|
self.adjustedY = riftOffsets and riftOffsets[self.data.id] and riftOffsets[self.data.id].y or clone.y
|
|
self:ClearAllPoints()
|
|
self:SetPoint("CENTER", MDT.main_frame.mapPanelTile1,"TOPLEFT",self.adjustedX*scale,self.adjustedY*scale)
|
|
self:SetMovable(true)
|
|
self.animatedLine = nil
|
|
setUpMouseHandlersAwakened(self,clone,scale,riftOffsets)
|
|
self:Hide()--hide by default, DungeonEnemies_UpdateSeasonalAffix handles showing
|
|
else
|
|
setUpMouseHandlers(self)
|
|
end
|
|
--tormented visual
|
|
if data.powers then
|
|
local tormentedColor = {0.7,0,1,1}
|
|
self.texture_Background:SetVertexColor(unpack(tormentedColor))
|
|
end
|
|
if emissaryIds[self.data.id] then self:Hide() end --hide beguiling emissaries by default
|
|
tinsert(blips,self)
|
|
if db.enemyStyle == 2 then
|
|
self.texture_Portrait:SetTexture("Interface\\Worldmap\\WorldMapPartyIcon")
|
|
else
|
|
if data.iconTexture then
|
|
SetPortraitToTexture(self.texture_Portrait,data.iconTexture);
|
|
else
|
|
SetPortraitTextureFromCreatureDisplayID(self.texture_Portrait,data.displayId or 39490)
|
|
end
|
|
end
|
|
self.texture_Indicator:Hide()
|
|
if db.devMode then blipDevModeSetup(self) end
|
|
end
|
|
|
|
---DungeonEnemies_IsAnyBlipMoving
|
|
function MDT:DungeonEnemies_IsAnyBlipMoving()
|
|
local isAnyMoving
|
|
for blipIdx,blip in pairs(blips) do
|
|
if blip:IsDragging() then
|
|
isAnyMoving = true
|
|
break
|
|
end
|
|
end
|
|
return isAnyMoving
|
|
end
|
|
|
|
---DungeonEnemies_HideAllBlips
|
|
---Used to hide blips during scaling changes to the map
|
|
function MDT:DungeonEnemies_HideAllBlips()
|
|
MDT.dungeonEnemies_framePools:ReleaseAll()
|
|
end
|
|
|
|
function MDT:DungeonEnemies_UpdateEnemies()
|
|
MDT.dungeonEnemies_framePools:ReleaseAll()
|
|
twipe(blips)
|
|
if not db then db = MDT:GetDB() end
|
|
local enemies = MDT.dungeonEnemies[db.currentDungeonIdx]
|
|
if not enemies then return end
|
|
preset = MDT:GetCurrentPreset()
|
|
|
|
local riftOffsets = MDT:GetRiftOffsets()
|
|
local currentSublevel = MDT:GetCurrentSubLevel()
|
|
|
|
for enemyIdx,data in pairs(enemies) do
|
|
for cloneIdx,clone in pairs(data["clones"]) do
|
|
--check sublevel
|
|
if clone.sublevel == currentSublevel or (not clone.sublevel) then
|
|
--skip rifts that were dragged to another sublevel
|
|
if not (data.corrupted and riftOffsets and riftOffsets[data.id] and riftOffsets[data.id].sublevel) then
|
|
local blip = MDT.dungeonEnemies_framePools:Acquire("MDTDungeonEnemyTemplate")
|
|
blip:SetUp(data,clone)
|
|
blip.enemyIdx = enemyIdx
|
|
blip.cloneIdx = cloneIdx
|
|
end
|
|
end
|
|
end
|
|
end
|
|
--add blips that were dragged to a different sublevel
|
|
if riftOffsets then
|
|
for npcId,offsetData in pairs(riftOffsets) do
|
|
if offsetData and offsetData.sublevel and offsetData.homeSublevel and offsetData.sublevel == currentSublevel then
|
|
for enemyIdx,data in pairs(enemies) do
|
|
if data.id == npcId then
|
|
for cloneIdx,clone in pairs(data["clones"]) do
|
|
local blip = MDT.dungeonEnemies_framePools:Acquire("MDTDungeonEnemyTemplate")
|
|
blip:SetUp(data,clone)
|
|
blip.enemyIdx = enemyIdx
|
|
blip.cloneIdx = cloneIdx
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDT:DungeonEnemies_CreateFramePools()
|
|
db = self:GetDB()
|
|
MDT.dungeonEnemies_framePools = MDT.dungeonEnemies_framePools or CreateFramePoolCollection()
|
|
MDT.dungeonEnemies_framePools:CreatePool("Button", MDT.main_frame.mapPanelFrame, "MDTDungeonEnemyTemplate");
|
|
end
|
|
|
|
function MDT:FindPullOfBlip(blip)
|
|
local preset = MDT:GetCurrentPreset()
|
|
local pulls = preset.value.pulls or {}
|
|
|
|
for pullIdx, pull in ipairs(pulls) do
|
|
if pull[blip.enemyIdx] then
|
|
for storageIdx, cloneIdx in ipairs(pull[blip.enemyIdx]) do
|
|
if cloneIdx == blip.cloneIdx then
|
|
return pullIdx
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
function MDT:GetBlip(enemyIdx, cloneIdx, preset)
|
|
for blipIdx,blip in pairs(blips) do
|
|
if blip.enemyIdx == enemyIdx and blip.cloneIdx == cloneIdx then
|
|
return blip
|
|
end
|
|
end
|
|
end
|
|
|
|
---DungeonEnemies_AddOrRemoveBlipToCurrentPull
|
|
---Adds or removes an enemy clone and all it's linked npcs to the currently selected pull
|
|
function MDT:DungeonEnemies_AddOrRemoveBlipToCurrentPull(blip, add, ignoreGrouped,pulls,pull,ignoreUpdates)
|
|
local preset = self:GetCurrentPreset()
|
|
local enemyIdx = blip.enemyIdx
|
|
local cloneIdx = blip.cloneIdx
|
|
pull = pull or preset.value.currentPull
|
|
pulls = pulls or preset.value.pulls or {}
|
|
pulls[pull] = pulls[pull] or {}
|
|
pulls[pull][enemyIdx] = pulls[pull][enemyIdx] or {}
|
|
--remove clone from all other pulls first
|
|
for pullIdx,p in pairs(pulls) do
|
|
if pullIdx ~= pull and p[enemyIdx] then
|
|
for k,v in pairs(p[enemyIdx]) do
|
|
if v == cloneIdx then
|
|
tremove(pulls[pullIdx][enemyIdx],k)
|
|
end
|
|
end
|
|
end
|
|
if not ignoreUpdates then self:UpdatePullButtonNPCData(pullIdx) end
|
|
end
|
|
if add then
|
|
if blip then blip.selected = true end
|
|
local found = false
|
|
for _,v in pairs(pulls[pull][enemyIdx]) do
|
|
if v == cloneIdx then found = true end
|
|
end
|
|
if found==false and blip:IsEnabled() then
|
|
tinsert(pulls[pull][enemyIdx],cloneIdx)
|
|
end
|
|
else
|
|
blip.selected = false
|
|
for k,v in pairs(pulls[pull][enemyIdx]) do
|
|
if v == cloneIdx then
|
|
tremove(pulls[pull][enemyIdx],k)
|
|
end
|
|
end
|
|
end
|
|
--linked npcs
|
|
if not ignoreGrouped then
|
|
for idx,otherBlip in pairs(blips) do
|
|
if blip.clone.g and otherBlip.clone.g == blip.clone.g and blip~=otherBlip then
|
|
self:DungeonEnemies_AddOrRemoveBlipToCurrentPull(otherBlip,add,true,pulls,pull,ignoreUpdates)
|
|
end
|
|
end
|
|
end
|
|
if not ignoreUpdates then self:UpdatePullButtonNPCData(pull) end
|
|
end
|
|
|
|
---DungeonEnemies_UpdateBlipColors
|
|
---Updates the colors of all selected blips of the specified pull
|
|
function MDT:DungeonEnemies_UpdateBlipColors(pull, r, g, b,pulls)
|
|
pulls = pulls or preset.value.pulls
|
|
local p = pulls[pull]
|
|
for enemyIdx,clones in pairs(p) do
|
|
if tonumber(enemyIdx) then
|
|
for _,cloneIdx in pairs(clones) do
|
|
for _,blip in pairs(blips) do
|
|
if (blip.enemyIdx == enemyIdx) and (blip.cloneIdx == cloneIdx) then
|
|
if not db.devMode then
|
|
if db.enemyStyle == 2 then
|
|
blip.texture_Portrait:SetVertexColor(r,g,b,1)
|
|
elseif not blip.data.corrupted then
|
|
blip.texture_Portrait:SetVertexColor(r,g,b,1)
|
|
blip.texture_SelectedHighlight:SetVertexColor(r,g,b,0.7)
|
|
end
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---Updates the selected Enemies on the map and marks them according to their pull color
|
|
function MDT:DungeonEnemies_UpdateSelected(pull,pulls)
|
|
preset = MDT:GetCurrentPreset()
|
|
pulls = pulls or preset.value.pulls
|
|
--deselect all
|
|
for _,blip in pairs(blips) do
|
|
blip.texture_SelectedHighlight:Hide()
|
|
blip.selected = false
|
|
blip.texture_PullIndicator:Hide()
|
|
if not db.devMode then
|
|
if db.enemyStyle == 2 then
|
|
blip.texture_Portrait:SetVertexColor(1,1,1,1)
|
|
else
|
|
if blip.data.corrupted then
|
|
blip.texture_Background:SetVertexColor(unpack(corruptedColor))
|
|
blip.texture_Portrait:SetVertexColor(1,1,1,1)
|
|
SetPortraitTextureFromCreatureDisplayID(blip.texture_Portrait,blip.data.displayId or 39490)
|
|
else
|
|
blip.texture_Portrait:SetVertexColor(1,1,1,1)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
--highlight all pull enemies
|
|
for pullIdx,p in pairs(pulls) do
|
|
local r,g,b = MDT:DungeonEnemies_GetPullColor(pullIdx)
|
|
for enemyIdx,clones in pairs(p) do
|
|
if tonumber(enemyIdx) then
|
|
for _,cloneIdx in pairs(clones) do
|
|
for _,blip in pairs(blips) do
|
|
if (blip.enemyIdx == enemyIdx) and (blip.cloneIdx == cloneIdx) then
|
|
blip.texture_SelectedHighlight:Show()
|
|
blip.selected = true
|
|
if not db.devMode then
|
|
if db.enemyStyle == 2 then
|
|
blip.texture_Portrait:SetVertexColor(0,1,0,1)
|
|
else
|
|
if blip.data.corrupted then
|
|
blip.texture_Portrait:SetAtlas("poi-rift1")
|
|
blip.texture_Background:SetVertexColor(0.5,1,0.1,1)
|
|
blip.texture_SelectedHighlight:Hide()
|
|
else
|
|
blip.texture_Portrait:SetVertexColor(r,g,b,1)
|
|
blip.texture_SelectedHighlight:SetVertexColor(r,g,b,0.7)
|
|
end
|
|
end
|
|
end
|
|
if pullIdx == pull then
|
|
blip.texture_PullIndicator:Show()
|
|
end
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
MDT:DrawAllHulls(pulls)
|
|
end
|
|
|
|
---DungeonEnemies_SetPullColor
|
|
---Sets a custom color for a pull
|
|
function MDT:DungeonEnemies_SetPullColor(pull, r, g, b)
|
|
preset = MDT:GetCurrentPreset()
|
|
preset.value.pulls[pull]["color"] = MDT:RGBToHex(r,g,b)
|
|
end
|
|
|
|
---DungeonEnemies_GetPullColor
|
|
---Returns the custom color for a pull
|
|
function MDT:DungeonEnemies_GetPullColor(pull,pulls)
|
|
pulls = pulls or preset.value.pulls
|
|
local r,g,b = MDT:HexToRGB(pulls[pull]["color"])
|
|
if not r then
|
|
r,g,b = MDT:HexToRGB(db.defaultColor)
|
|
MDT:DungeonEnemies_SetPullColor(pull,r,g,b)
|
|
end
|
|
return r,g,b
|
|
end
|
|
|
|
---DungeonEnemies_UpdateTeeming
|
|
---Updates visibility state of teeming blips
|
|
function MDT:DungeonEnemies_UpdateTeeming()
|
|
preset = MDT:GetCurrentPreset()
|
|
local teeming = MDT:IsPresetTeeming(preset)
|
|
for _,blip in pairs(blips) do
|
|
if teeming then
|
|
if blip.clone.negativeTeeming then
|
|
blip:Hide()
|
|
else
|
|
blip:Show()
|
|
end
|
|
else
|
|
if blip.clone.teeming then
|
|
blip:Hide()
|
|
else
|
|
blip:Show()
|
|
end
|
|
end
|
|
end
|
|
MDT:DungeonEnemies_UpdateBlacktoothEvent()
|
|
end
|
|
|
|
---DungeonEnemies_UpdateSeasonalAffix
|
|
---Updates visibility state and appearance of enemies related to the current seasonal affix
|
|
function MDT:DungeonEnemies_UpdateSeasonalAffix()
|
|
--hide all beguiling and corrupted blips first
|
|
for _,blip in pairs(blips) do
|
|
if blip.data.corrupted then blip:Hide() end
|
|
if emissaryIds[blip.data.id] then blip:Hide() end
|
|
if tormentedIds[blip.data.id] then blip:Hide() end
|
|
end
|
|
local week = self:GetEffectivePresetWeek()
|
|
for _,blip in pairs(blips) do
|
|
if db.currentSeason == 6 and tormentedIds[blip.data.id] and db.currentDifficulty >= 10 then blip:Show() end
|
|
if (db.currentSeason == 4 and blip.data.corrupted) or(db.currentSeason == 3 and emissaryIds[blip.data.id]) then
|
|
local weekData = blip.clone.week
|
|
if weekData and (not weekData[week] or db.currentDifficulty < 10) then
|
|
blip:Hide()
|
|
elseif weekData and weekData[week] then
|
|
blip:Show()
|
|
elseif not weekData and blip.data.corrupted then
|
|
blip:Show()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
---DungeonEnemies_UpdateBlacktoothEvent
|
|
---Updates visibility state of blacktooth event blips
|
|
function MDT:DungeonEnemies_UpdateBlacktoothEvent()
|
|
local week
|
|
if db.MDI.enabled then
|
|
week = preset.mdi.freehold or 1
|
|
else
|
|
week = preset.week%3
|
|
end
|
|
if week == 0 then week = 3 end
|
|
local isBlacktoothWeek = week == 2
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.blacktoothEvent then
|
|
if isBlacktoothWeek then
|
|
blip:Enable()
|
|
blip:Show()
|
|
else
|
|
blip:Disable()
|
|
blip:Hide()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDT:DungeonEnemies_UpdateBoralusFaction(faction)
|
|
preset = MDT:GetCurrentPreset()
|
|
local teeming = MDT:IsPresetTeeming(preset)
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.faction then
|
|
--handle beguiling npcs here
|
|
if emissaryIds[blip.data.id] then
|
|
local week
|
|
if db.MDI.enabled then
|
|
week = preset.mdi.beguiling or 1
|
|
else
|
|
week = preset.week
|
|
end
|
|
local weekData = blip.clone.week
|
|
if weekData and not weekData[week] then
|
|
blip:Hide()
|
|
elseif weekData and weekData[week] then
|
|
if blip.clone.faction == faction then
|
|
blip:Show()
|
|
else
|
|
blip:Hide()
|
|
end
|
|
end
|
|
else
|
|
if blip.clone.faction == faction and ((teeming and blip.clone.teeming) or (not blip.clone.teeming)) then
|
|
blip:Show()
|
|
else
|
|
blip:Hide()
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDT:DungeonEnemies_UpdateReaping()
|
|
for _,blip in pairs(blips) do
|
|
if blip.data.reaping then
|
|
blip.texture_Reaping:Show()
|
|
else
|
|
blip.texture_Reaping:Hide()
|
|
end
|
|
|
|
if db.currentDifficulty < 10 then
|
|
blip.texture_Reaping:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
---DungeonEnemies_UpdateInfested
|
|
---Updates which blips should display infested state based on preset.week
|
|
function MDT:DungeonEnemies_UpdateInfested(week)
|
|
week = preset.week%3
|
|
if week == 0 then week = 3 end
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.infested and blip.clone.infested[week] then
|
|
blip.texture_Indicator:Show()
|
|
else
|
|
blip.texture_Indicator:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
---DungeonEnemies_UpdateInspiring
|
|
---Updates which blips should display inspiring state based on preset.week
|
|
function MDT:DungeonEnemies_UpdateInspiring(week)
|
|
week = week or preset.week
|
|
local isInspiring = MDT:IsWeekInspiring(week)
|
|
for _,blip in pairs(blips) do
|
|
if blip.clone.inspiring and isInspiring then
|
|
blip.texture_Indicator:SetVertexColor(1,1,0,1)
|
|
blip.texture_Indicator:SetScale(1.15)
|
|
blip.texture_Indicator:Show()
|
|
else
|
|
blip.texture_Indicator:Hide()
|
|
end
|
|
end
|
|
end
|
|
|
|
---Frehold Crews
|
|
MDT.freeholdCrews = {
|
|
[2] = {--blacktooth
|
|
[129548] = true,
|
|
[129529] = true,
|
|
[129547] = true,
|
|
[126847] = true,
|
|
},
|
|
[1] = {--cutwater
|
|
[129559] = true,
|
|
[129599] = true,
|
|
[126845] = true,
|
|
[129601] = true,
|
|
},
|
|
[3] = {--bilge rat
|
|
[129550] = true,
|
|
[129527] = true,
|
|
[129600] = true,
|
|
[129526] = true,
|
|
[126848] = true,
|
|
},
|
|
}
|
|
---DungeonEnemies_UpdateFreeholdCrew
|
|
---Updates the enemies in Freehold to reflect the weekly event of "joining" a crew i.e. disabling npcs of the crew
|
|
function MDT:DungeonEnemies_UpdateFreeholdCrew(crewIdx)
|
|
--override crew with mdi data
|
|
if db.MDI.enabled then
|
|
crewIdx = (preset.mdi.freeholdJoined and preset.mdi.freehold) or nil
|
|
end
|
|
--if we are not in freehold map we need to tidy up our mess a bit
|
|
if not crewIdx then
|
|
for _,blip in pairs(blips) do
|
|
blip:Enable()
|
|
blip:SetAlpha(1)
|
|
blip.texture_Portrait:SetDesaturated(false)
|
|
end
|
|
return
|
|
end
|
|
|
|
local crew = MDT.freeholdCrews[crewIdx]
|
|
for _,blip in pairs(blips) do
|
|
if crew[blip.data.id] and not blip.clone.blacktoothEvent then
|
|
blip:Disable()
|
|
blip:SetAlpha(0.3)
|
|
blip.texture_Portrait:SetDesaturated(true)
|
|
else
|
|
blip:Enable()
|
|
blip:SetAlpha(1)
|
|
blip.texture_Portrait:SetDesaturated(false)
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDT:IsNPCInPulls(poi)
|
|
local week = self:GetEffectivePresetWeek()
|
|
local data = self.dungeonEnemies[db.currentDungeonIdx]
|
|
for enemyIdx,enemy in pairs(data) do
|
|
if enemy.id == poi.npcId then
|
|
local included = false
|
|
for cloneIdx,clone in pairs(enemy.clones) do
|
|
if clone.week[week] then
|
|
return MDT:IsCloneInPulls(enemyIdx,cloneIdx)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
function MDT:IsCloneInPulls(enemyIdx, cloneIdx)
|
|
local pulls = MDT:GetCurrentPreset().value.pulls
|
|
local numClones = 0
|
|
for _,pull in pairs(pulls) do
|
|
if pull[enemyIdx] then
|
|
if cloneIdx then
|
|
for _,pullCloneIndex in pairs(pull[enemyIdx]) do
|
|
if pullCloneIndex == cloneIdx then return true end
|
|
end
|
|
else
|
|
for _,pullCloneIndex in pairs(pull[enemyIdx]) do
|
|
numClones = numClones+1
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return numClones>0
|
|
end
|
|
|
|
local countCache = {}
|
|
---returns count, maxCountNormal, maxCountTeeming, teemingCount
|
|
function MDT:GetEnemyForces(npcId)
|
|
if countCache[npcId] then
|
|
return countCache[npcId].count,countCache[npcId].maxCountNormal,countCache[npcId].maxCountTeeming,countCache[npcId].teemingCount
|
|
else
|
|
for i = 1,self:GetNumDungeons() do
|
|
local data = self.dungeonEnemies[i]
|
|
if data then
|
|
for enemyIdx,enemy in pairs(data) do
|
|
if enemy.id == npcId then
|
|
--awakened fix
|
|
if enemy.corrupted then
|
|
local zoneId = C_Map.GetBestMapForUnit("player")
|
|
local dungeonIdx = self.zoneIdToDungeonIdx[zoneId] or i
|
|
data = self.dungeonEnemies[dungeonIdx]
|
|
for enemyIdx,enemy in pairs(data) do
|
|
if enemy.id == npcId then
|
|
return enemy.count,self.dungeonTotalCount[dungeonIdx].normal,self.dungeonTotalCount[dungeonIdx].teeming,enemy.teemingCount
|
|
end
|
|
end
|
|
else
|
|
countCache[npcId] = {
|
|
["count"] = enemy.count,
|
|
["maxCountNormal"] = self.dungeonTotalCount[i].normal,
|
|
["maxCountTeeming"] = self.dungeonTotalCount[i].teeming,
|
|
["teemingCount"] = enemy.teemingCount or enemy.count,
|
|
}
|
|
return countCache[npcId].count,countCache[npcId].maxCountNormal,countCache[npcId].maxCountTeeming,countCache[npcId].teemingCount
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
---tries to retrieve npc name by npcId
|
|
---only looks for npcs in the current dungeon
|
|
function MDT:GetNPCNameById(npcId)
|
|
local data = MDT.dungeonEnemies[db.currentDungeonIdx]
|
|
if data then
|
|
for _,enemy in pairs(data) do
|
|
if enemy.id == npcId then
|
|
return enemy.name
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
---updates the enemy tables with new count and teemingCount or displayId values
|
|
---data is retrieved with the the get_count.py or get_displayids python script
|
|
---data needs to afterwards be exported manually for every dungeon
|
|
function MDT:UpdateDungeonData(dungeonData)
|
|
|
|
local function printDungeonName(shouldPrint,dungeonIdx)
|
|
if shouldPrint then
|
|
print("-----", MDT:GetDungeonName(dungeonIdx))
|
|
end
|
|
return false
|
|
end
|
|
|
|
for dungeonIdx,newData in pairs(dungeonData) do
|
|
|
|
--dungeon total count changes
|
|
local totalCount = MDT.dungeonTotalCount[dungeonIdx]
|
|
if newData[0] and (newData[0].count~=totalCount.normal or newData[0].teeming_count~=totalCount.teeming) then
|
|
print("TOTAL ",totalCount.normal,totalCount.teeming,">>>",newData[0].count,newData[0].teeming_count)
|
|
totalCount.normal = newData[0].count
|
|
totalCount.teeming = newData[0].teeming_count
|
|
end
|
|
|
|
--enemy changes
|
|
local shouldPrintDungeonName = true
|
|
local enemyData = MDT.dungeonEnemies[dungeonIdx]
|
|
if enemyData then
|
|
for _,enemy in pairs(enemyData) do
|
|
--ignore enchanted emissary (gives count but can almost never pull it off, keep 0 to keep it simple)
|
|
--ignore spark channeler, always gives 11 count but data says 6
|
|
if newData[enemy.id] and (enemy.id ~= 155432 and enemy.id ~= 139110) then
|
|
|
|
if newData[enemy.id].count then
|
|
--normal count changes
|
|
if newData[enemy.id].count~=enemy.count then
|
|
shouldPrintDungeonName= printDungeonName(shouldPrintDungeonName,dungeonIdx)
|
|
print(enemy.name,enemy.id, enemy.count, ">>>", newData[enemy.id].count)
|
|
enemy.count = newData[enemy.id].count
|
|
end
|
|
|
|
--teeming count changes
|
|
if newData[enemy.id].count~= newData[enemy.id].teeming_count
|
|
and (newData[enemy.id].count~=enemy.count or newData[enemy.id].teeming_count~=enemy.teemingCount)
|
|
then
|
|
shouldPrintDungeonName= printDungeonName(shouldPrintDungeonName,dungeonIdx)
|
|
print("TEEMING ",enemy.name,enemy.id, newData[enemy.id].count,"||", newData[enemy.id].teeming_count)
|
|
enemy.count = newData[enemy.id].count
|
|
enemy.teemingCount = newData[enemy.id].teeming_count
|
|
end
|
|
end
|
|
|
|
--displayId changes
|
|
if newData[enemy.id].displayId and newData[enemy.id].displayId~=enemy.displayId then
|
|
shouldPrintDungeonName= printDungeonName(shouldPrintDungeonName,dungeonIdx)
|
|
print("DISPLAYID ",enemy.name,enemy.id,enemy.displayId, ">>>",newData[enemy.id].displayId)
|
|
enemy.displayId = newData[enemy.id].displayId
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
---exports all ids of npcs that do not have a displayId associated to them
|
|
--dungeons = [
|
|
--Dungeon(name='AtalDazar', idx=15, npcIds=[134739, 161241, 136347]),
|
|
-- Dungeon(name='RandomDungeon', idx=14, npcIds=[161241, 134739, 136347]),
|
|
--]
|
|
function MDT:ExportNPCIdsWithoutDisplayIds()
|
|
local output = "dungeons = [\n"
|
|
for idx = 15, MDT:GetNumDungeons() do
|
|
local shouldAddDungeonText = true
|
|
local enemyData = MDT.dungeonEnemies[idx]
|
|
if enemyData then
|
|
for _,enemy in pairs(enemyData) do
|
|
if not enemy.displayId then
|
|
if shouldAddDungeonText then
|
|
output = output.."Dungeon(name='".. MDT:GetDungeonName(idx).."', idx=".. idx..", npcIds=["
|
|
shouldAddDungeonText = false
|
|
end
|
|
output = output..enemy.id..", "
|
|
end
|
|
end
|
|
if not shouldAddDungeonText then output = output.."]),\n" end
|
|
end
|
|
end
|
|
output = output.."]"
|
|
MDT:HideAllDialogs()
|
|
MDT.main_frame.ExportFrame:Show()
|
|
MDT.main_frame.ExportFrame:ClearAllPoints()
|
|
MDT.main_frame.ExportFrame:SetPoint("CENTER", MDT.main_frame,"CENTER",0,50)
|
|
MDT.main_frame.ExportFrameEditbox:SetText(output)
|
|
MDT.main_frame.ExportFrameEditbox:HighlightText(0, string.len(output))
|
|
MDT.main_frame.ExportFrameEditbox:SetFocus()
|
|
MDT.main_frame.ExportFrameEditbox:SetLabel("NPC ids without displayId")
|
|
end
|
|
|
|
|
|
local function ArrayRemove(t, fnKeep)
|
|
local j, n = 1, #t;
|
|
|
|
for i=1,n do
|
|
if (fnKeep(t, i, j)) then
|
|
-- Move i's kept value to j's position, if it's not already there.
|
|
if (i ~= j) then
|
|
t[j] = t[i];
|
|
t[i] = nil;
|
|
end
|
|
j = j + 1; -- Increment position of where we'll place the next kept value.
|
|
else
|
|
t[i] = nil;
|
|
end
|
|
end
|
|
|
|
return t;
|
|
end
|
|
|
|
---removes enemies of the current dungeon without any clones
|
|
function MDT:CleanEnemyData(dungeonIdx)
|
|
local enemies = MDT.dungeonEnemies[dungeonIdx]
|
|
ArrayRemove(enemies,function (t, i , j)
|
|
return #t[i].clones>0
|
|
end)
|
|
|
|
end
|
|
|