SHARE
TWEET

Untitled

a guest Jul 26th, 2019 67 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. local sIsRestoredAfterDc = false;
  2.  
  3. VUHDO_IN_COMBAT_RELOG = false;
  4.  
  5. VUHDO_DEBUG = { };
  6.  
  7.  
  8. VUHDO_RAID = { };
  9. local VUHDO_RAID;
  10.  
  11. VUHDO_RAID_NAMES = { };
  12. local VUHDO_RAID_NAMES = VUHDO_RAID_NAMES;
  13.  
  14. VUHDO_GROUPS = { };
  15. local VUHDO_GROUPS = VUHDO_GROUPS;
  16.  
  17. VUHDO_RAID_GUIDS = { };
  18. local VUHDO_RAID_GUIDS = VUHDO_RAID_GUIDS;
  19.  
  20. VUHDO_EMERGENCIES = { };
  21. local VUHDO_EMERGENCIES = VUHDO_EMERGENCIES;
  22.  
  23. VUHDO_CLUSTER_BASE_RAID = { };
  24. local VUHDO_CLUSTER_BASE_RAID = VUHDO_CLUSTER_BASE_RAID;
  25.  
  26. VUHDO_PLAYER_TARGETS = { };
  27.  
  28. local VUHDO_IS_SUSPICIOUS_ROSTER = false;
  29.  
  30. local VUHDO_RAID_SORTED = { };
  31. local VUHDO_MAINTANKS = { };
  32. local VUHDO_INTERNAL_TOGGLES = { };
  33. local VUHDO_PANEL_UNITS = { };
  34. setmetatable(VUHDO_PANEL_UNITS, VUHDO_META_NEW_ARRAY);
  35.  
  36. -- TODO: make local
  37. VUHDO_BOSS_UNITS = { };
  38.  
  39. for i = 1, MAX_BOSS_FRAMES do
  40.     local bossUnitId = format("boss%d", i);
  41.  
  42.     VUHDO_BOSS_UNITS[bossUnitId] = true;
  43. end
  44.  
  45. VUHDO_PLAYER_CLASS = nil;
  46. VUHDO_PLAYER_NAME = nil;
  47. VUHDO_PLAYER_RAID_ID = nil;
  48. VUHDO_PLAYER_GROUP = nil;
  49.  
  50. -- BURST CACHE ---------------------------------------------------
  51. local VUHDO_CONFIG;
  52. local VUHDO_PET_2_OWNER;
  53. local VUHDO_OWNER_2_PET;
  54.  
  55. local VUHDO_getUnitIds;
  56. local VUHDO_getUnitNo;
  57. local VUHDO_isInRange;
  58. local VUHDO_determineDebuff;
  59. local VUHDO_getUnitGroup;
  60. local VUHDO_tableUniqueAdd;
  61. local VUHDO_getTargetUnit;
  62. local VUHDO_updateHealthBarsFor;
  63. local VUHDO_trimInspected;
  64.  
  65. local VUHDO_getPlayerRaidUnit;
  66. local VUHDO_getModelType;
  67. local VUHDO_isConfigDemoUsers;
  68. local VUHDO_updateBouquetsForEvent;
  69. local VUHDO_resetClusterCoordDeltas;
  70. local VUHDO_getUnitZoneName;
  71. local VUHDO_isModelInPanel;
  72. local VUHDO_isAltPowerActive;
  73. local VUHDO_isModelConfigured;
  74. local VUHDO_determineRole;
  75. local VUHDO_getUnitHealthPercent;
  76. local VUHDO_isUnitInModel;
  77. local VUHDO_isUnitInModelIterative;
  78. local VUHDO_isUnitInPanel;
  79. local VUHDO_initDynamicPanelModels;
  80. local VUHDO_updateBuffRaidGroup;
  81.  
  82. local GetRaidTargetIndex = GetRaidTargetIndex;
  83. local UnitIsDeadOrGhost = UnitIsDeadOrGhost;
  84. local UnitIsFeignDeath = UnitIsFeignDeath;
  85. local UnitExists = UnitExists;
  86. local UnitHealth = UnitHealth;
  87. -- Disable local alias so function can be overloaded by Velhari Health Fix addon
  88. --local UnitHealthMax = UnitHealthMax;
  89. local string = string;
  90. local UnitIsAFK = UnitIsAFK;
  91. local UnitIsConnected = UnitIsConnected;
  92. local UnitIsCharmed = UnitIsCharmed;
  93. local UnitInRaid = UnitInRaid;
  94. local UnitHasVehicleUI = UnitHasVehicleUI;
  95. local UnitTargetsVehicleInRaidUI = UnitTargetsVehicleInRaidUI;
  96. local UnitCanAttack = UnitCanAttack;
  97. local GetNumGroupMembers = GetNumGroupMembers;
  98. local UnitName = UnitName;
  99. local UnitPower = UnitPower;
  100. local UnitPowerMax = UnitPowerMax;
  101. local UnitThreatSituation = UnitThreatSituation;
  102. local UnitClass = UnitClass;
  103. local UnitPowerType = UnitPowerType;
  104. local UnitHasVehicleUI = UnitHasVehicleUI;
  105. local UnitGroupRolesAssigned = UnitGroupRolesAssigned;
  106. local GetRaidRosterInfo = GetRaidRosterInfo;
  107. local InCombatLockdown = InCombatLockdown;
  108. local IsInRaid = IsInRaid;
  109. local table = table;
  110. local UnitGUID = UnitGUID;
  111. local tinsert = tinsert;
  112. local tremove = tremove;
  113. local strfind = strfind;
  114. --local VUHDO_PANEL_MODELS;
  115. local GetTime = GetTime;
  116. local pairs = pairs;
  117. local ipairs = ipairs;
  118. local twipe = table.wipe;
  119. local tsort = table.sort;
  120. local _;
  121. local sTrigger;
  122. local sCurrentMode;
  123.  
  124.  
  125. function VUHDO_vuhdoInitLocalOverrides()
  126.     VUHDO_CONFIG = _G["VUHDO_CONFIG"];
  127.     VUHDO_RAID = _G["VUHDO_RAID"];
  128.     VUHDO_PET_2_OWNER = _G["VUHDO_PET_2_OWNER"];
  129.     VUHDO_OWNER_2_PET = _G["VUHDO_OWNER_2_PET"];
  130.     VUHDO_getUnitIds = _G["VUHDO_getUnitIds"];
  131.     VUHDO_getUnitNo = _G["VUHDO_getUnitNo"];
  132.     VUHDO_isInRange = _G["VUHDO_isInRange"];
  133.     VUHDO_determineDebuff = _G["VUHDO_determineDebuff"];
  134.     VUHDO_getUnitGroup = _G["VUHDO_getUnitGroup"];
  135.     VUHDO_updateHealthBarsFor = _G["VUHDO_updateHealthBarsFor"];
  136.     VUHDO_tableUniqueAdd = _G["VUHDO_tableUniqueAdd"];
  137.     VUHDO_trimInspected = _G["VUHDO_trimInspected"];
  138.     VUHDO_getTargetUnit = _G["VUHDO_getTargetUnit"];
  139.     VUHDO_getModelType = _G["VUHDO_getModelType"];
  140.     VUHDO_isModelInPanel = _G["VUHDO_isModelInPanel"];
  141.     VUHDO_isAltPowerActive = _G["VUHDO_isAltPowerActive"];
  142.     VUHDO_getPlayerRaidUnit = _G["VUHDO_getPlayerRaidUnit"];
  143.     VUHDO_isModelConfigured = _G["VUHDO_isModelConfigured"];
  144.     VUHDO_isUnitInModel = _G["VUHDO_isUnitInModel"];
  145.     VUHDO_isUnitInModelIterative = _G["VUHDO_isUnitInModelIterative"];
  146.     VUHDO_isUnitInPanel = _G["VUHDO_isUnitInPanel"];
  147.     VUHDO_initDynamicPanelModels = _G["VUHDO_initDynamicPanelModels"];
  148.     VUHDO_updateBuffRaidGroup = _G["VUHDO_updateBuffRaidGroup"];
  149.  
  150.     --VUHDO_PANEL_MODELS = _G["VUHDO_PANEL_MODELS"];
  151.     VUHDO_determineRole = _G["VUHDO_determineRole"];
  152.     VUHDO_getUnitHealthPercent = _G["VUHDO_getUnitHealthPercent"];
  153.     VUHDO_isConfigDemoUsers = _G["VUHDO_isConfigDemoUsers"];
  154.     VUHDO_updateBouquetsForEvent = _G["VUHDO_updateBouquetsForEvent"];
  155.     VUHDO_resetClusterCoordDeltas = _G["VUHDO_resetClusterCoordDeltas"];
  156.     VUHDO_getUnitZoneName = _G["VUHDO_getUnitZoneName"];
  157.     VUHDO_INTERNAL_TOGGLES = _G["VUHDO_INTERNAL_TOGGLES"];
  158.     VUHDO_PANEL_UNITS = _G["VUHDO_PANEL_UNITS"];
  159.  
  160.     sTrigger = VUHDO_CONFIG["EMERGENCY_TRIGGER"];
  161.     sCurrentMode = VUHDO_CONFIG["MODE"];
  162.  
  163.     VUHDO_DEFAULT_PROFILE = _G["VUHDO_DEFAULT_PROFILE"];
  164.     VUHDO_DEFAULT_LAYOUT = _G["VUHDO_DEFAULT_LAYOUT"];
  165.    
  166.  
  167. end
  168.  
  169. isboxer_load = false;
  170.  
  171.  
  172. ----------------------------------------------------
  173.  
  174. local VUHDO_UNIT_AFK_DC = { };
  175.  
  176.  
  177.  
  178. --
  179. local function VUHDO_updateAllRaidNames()
  180.     twipe(VUHDO_RAID_NAMES);
  181.  
  182.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  183.         if not VUHDO_isSpecialUnit(tUnit) then
  184.             -- ensure not to overwrite a player name with a pet's identical name
  185.             if not VUHDO_RAID_NAMES[tInfo["name"]] or not tInfo["isPet"] then
  186.                 VUHDO_RAID_NAMES[tInfo["name"]] = tUnit;
  187.             end
  188.         end
  189.     end
  190. end
  191.  
  192.  
  193.  
  194. --
  195. local function VUHDO_isValidEmergency(anInfo)
  196.     return not anInfo["isPet"] and anInfo["range"] and not anInfo["dead"]
  197.         and anInfo["connected"] and not anInfo["charmed"];
  198. end
  199.  
  200.  
  201.  
  202. --
  203. local function VUHDO_setTopEmergencies(aMaxAnz)
  204.     twipe(VUHDO_EMERGENCIES);
  205.     for tIndex, tUnit in ipairs(VUHDO_RAID_SORTED) do
  206.         VUHDO_EMERGENCIES[tUnit] = tIndex;
  207.         if tIndex == aMaxAnz then return; end
  208.     end
  209. end
  210.  
  211.  
  212.  
  213. --
  214. local VUHDO_EMERGENCY_SORTERS = {
  215.     [VUHDO_MODE_EMERGENCY_MOST_MISSING]
  216.         = function(aUnit, anotherUnit)
  217.                 return VUHDO_RAID[aUnit]["healthmax"] - VUHDO_RAID[aUnit]["health"]
  218.                             > VUHDO_RAID[anotherUnit]["healthmax"] - VUHDO_RAID[anotherUnit]["health"];
  219.             end,
  220.  
  221.     [VUHDO_MODE_EMERGENCY_PERC]
  222.         = function(aUnit, anotherUnit)
  223.                     return VUHDO_RAID[aUnit]["health"] / VUHDO_RAID[aUnit]["healthmax"]
  224.                                 < VUHDO_RAID[anotherUnit]["health"] / VUHDO_RAID[anotherUnit]["healthmax"];
  225.             end,
  226.  
  227.     [VUHDO_MODE_EMERGENCY_LEAST_LEFT]
  228.         = function(aUnit, anotherUnit)
  229.                 return VUHDO_RAID[aUnit]["health"] < VUHDO_RAID[anotherUnit]["health"];
  230.             end,
  231. }
  232.  
  233.  
  234.  
  235. --
  236. local function VUHDO_sortEmergencies()
  237.     twipe(VUHDO_RAID_SORTED);
  238.  
  239.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  240.         if not VUHDO_isSpecialUnit(tUnit)
  241.             and VUHDO_getUnitHealthPercent(tInfo) < sTrigger and VUHDO_isValidEmergency(tInfo) then
  242.  
  243.             VUHDO_RAID_SORTED[#VUHDO_RAID_SORTED + 1] = tUnit;
  244.         end
  245.     end
  246.  
  247.     tsort(VUHDO_RAID_SORTED, VUHDO_EMERGENCY_SORTERS[sCurrentMode]);
  248.     VUHDO_setTopEmergencies(VUHDO_CONFIG["MAX_EMERGENCIES"]);
  249. end
  250.  
  251.  
  252.  
  253. -- Avoid reordering sorting by max-health if someone dies or gets offline
  254. local tEmptyInfo = {};
  255. local function VUHDO_getUnitSortMaxHp(aUnit)
  256.     return VUHDO_RAID[aUnit][
  257.         ((VUHDO_RAID[aUnit] or tEmptyInfo)["sortMaxHp"] ~= nil and InCombatLockdown())
  258.             and "sortMaxHp" or "healthmax"
  259.     ];
  260. end
  261.  
  262.  
  263.  
  264. --
  265. local tIsAfk;
  266. local tIsConnected;
  267. local function VUHDO_updateAfkDc(aUnit)
  268.     tIsAfk = UnitIsAFK(aUnit);
  269.     tIsConnected = UnitIsConnected(aUnit);
  270.     if tIsAfk or not tIsConnected then
  271.         if not VUHDO_UNIT_AFK_DC[aUnit] then VUHDO_UNIT_AFK_DC[aUnit] = GetTime(); end
  272.     else
  273.         VUHDO_UNIT_AFK_DC[aUnit] = nil;
  274.     end
  275.  
  276.     return tIsAfk, tIsConnected, VUHDO_RAID[aUnit] ~= nil and tIsConnected ~= VUHDO_RAID[aUnit]["connected"];
  277. end
  278.  
  279.  
  280.  
  281. --
  282. function VUHDO_getAfkDcTime(aUnit)
  283.     return VUHDO_UNIT_AFK_DC[aUnit];
  284. end
  285.  
  286.  
  287.  
  288. -- Sets a Member info into raid array
  289. local tUnitId;
  290. local tIsPet;
  291. local tClassName;
  292. local tPowerType;
  293. local tIsAfk, tIsConnected;
  294. local tLocalClass;
  295. local tIsDead;
  296. local tClassId;
  297. local tInfo;
  298. local tNewHealth;
  299. local tName, tRealm;
  300. local tIsDcChange;
  301. local tOwner;
  302. function VUHDO_setHealth(aUnit, aMode)
  303.  
  304.     tInfo = VUHDO_RAID[aUnit];
  305.  
  306.     tUnitId = VUHDO_getUnitIds();
  307.     tOwner = VUHDO_PET_2_OWNER[aUnit];
  308.     tIsPet = tOwner ~= nil;
  309.  
  310.     if strfind(aUnit, tUnitId, 1, true) or tIsPet or aUnit == "player" or VUHDO_isSpecialUnit(aUnit) then
  311.  
  312.         tIsDead = UnitIsDeadOrGhost(aUnit) and not UnitIsFeignDeath(aUnit);
  313.         if tIsDead then
  314.             VUHDO_removeAllDebuffIcons(aUnit);
  315.             VUHDO_removeHots(aUnit);
  316.             VUHDO_initEventBouquetsFor(aUnit);
  317.         end
  318.  
  319.         if 1 == aMode then -- VUHDO_UPDATE_ALL
  320.             tLocalClass, tClassName = UnitClass(aUnit);
  321.             tPowerType = UnitPowerType(aUnit);
  322.             tIsAfk, tIsConnected, _ = VUHDO_updateAfkDc(aUnit);
  323.  
  324.             if not VUHDO_RAID[aUnit] then   VUHDO_RAID[aUnit] = { }; end
  325.             tInfo = VUHDO_RAID[aUnit];
  326.             tInfo["ownerUnit"] = tOwner;
  327.  
  328.             if tIsPet and tClassId then
  329.                 if VUHDO_USER_CLASS_COLORS["petClassColor"] and VUHDO_RAID[tInfo["ownerUnit"]] then
  330.                     tClassId = VUHDO_RAID[tInfo["ownerUnit"]]["classId"] or VUHDO_ID_PETS;
  331.                 else
  332.                     tClassId = VUHDO_ID_PETS;
  333.                 end
  334.             else
  335.                 tClassId = VUHDO_CLASS_IDS[tClassName];
  336.             end
  337.  
  338.             tName, tRealm = UnitName(aUnit);
  339.             tInfo["healthmax"] = UnitHealthMax(aUnit);
  340.             tInfo["health"] = UnitHealth(aUnit);
  341.             tInfo["name"] = tName;
  342.             tInfo["number"] = VUHDO_getUnitNo(aUnit);
  343.             tInfo["unit"] = aUnit;
  344.             tInfo["class"] = tClassName;
  345.             tInfo["range"] = VUHDO_isInRange(aUnit);
  346.             tInfo["debuff"], tInfo["debuffName"] = VUHDO_determineDebuff(aUnit);
  347.             tInfo["isPet"] = tIsPet;
  348.             tInfo["powertype"] = tonumber(tPowerType);
  349.             tInfo["power"] = UnitPower(aUnit);
  350.             tInfo["powermax"] = UnitPowerMax(aUnit);
  351.             tInfo["charmed"] = UnitIsCharmed(aUnit) and UnitCanAttack("player", aUnit);
  352.             tInfo["aggro"] = false;
  353.             tInfo["group"] = VUHDO_getUnitGroup(aUnit, tIsPet);
  354.             tInfo["dead"] = tIsDead;
  355.             tInfo["afk"] = tIsAfk;
  356.             tInfo["connected"] = tIsConnected;
  357.             tInfo["threat"] = UnitThreatSituation(aUnit) or 0;
  358.             tInfo["threatPerc"] = 0;
  359.             tInfo["isVehicle"] = UnitHasVehicleUI(aUnit);
  360.             tInfo["className"] = tLocalClass or "";
  361.             tInfo["petUnit"] = VUHDO_OWNER_2_PET[aUnit];
  362.             tInfo["targetUnit"] = VUHDO_getTargetUnit(aUnit);
  363.             tInfo["classId"] = tClassId;
  364.             tInfo["sortMaxHp"] = VUHDO_getUnitSortMaxHp(aUnit);
  365.             tInfo["role"] = VUHDO_determineRole(aUnit);
  366.             tInfo["fullName"] = (tRealm or "") ~= "" and (tName .. "-" .. tRealm) or tName;
  367.             tInfo["raidIcon"] = GetRaidTargetIndex(aUnit);
  368.             tInfo["visible"] = UnitIsVisible(aUnit); -- Reihenfolge beachten
  369.             tInfo["zone"], tInfo["map"] = VUHDO_getUnitZoneName(aUnit); -- ^^
  370.             tInfo["baseRange"] = UnitInRange(aUnit) or "player" == aUnit;
  371.             tInfo["isAltPower"] = VUHDO_isAltPowerActive(aUnit);
  372.             --[[tInfo["missbuff"] = nil;
  373.             tInfo["mibucateg"] = nil;
  374.             tInfo["mibuvariants"] = nil;]]
  375.            
  376.             do_quickRaidReload = false
  377.             if IsAddOnLoaded("Isboxer" ) then
  378.                 if isboxer_load == false  and not InCombatLockdown() then  
  379.                     table.wipe(VUHDO_PLAYER_TARGETS);
  380.                 end
  381.                 for value, data in pairs( isboxer.CharacterSet ) do
  382.                     if value == "Members" then
  383.                         for slot, isboxerCharacterName in pairs( data ) do
  384.                             isboxerCharacterName = gsub(isboxerCharacterName, "%-[^|]+", "")
  385.                             if tName == isboxerCharacterName then tInfo["sortMaxHp"] = tInfo["sortMaxHp"]+(1000000*slot); end
  386.                             if isboxer_load == false and not InCombatLockdown() then   
  387.                                     VUHDO_PLAYER_TARGETS[isboxerCharacterName] = true;
  388.                                     do_quickRaidReload = true;
  389.                             end
  390.                             if VUHDO_RAID_NAMES[isboxerCharacterName] ~= nil then
  391.                                 VUHDO_PLAYER_TARGETS[isboxerCharacterName] = true;
  392.                                 do_quickRaidReload = true
  393.                             end
  394.                         end
  395.                     end        
  396.                 end
  397.                 if do_quickRaidReload == true then
  398.                     isboxer_load = true;
  399.                     VUHDO_quickRaidReload();
  400.                 end
  401.             end
  402.    
  403.             if not VUHDO_isSpecialUnit(aUnit) then
  404.                 if not tIsPet and tInfo["fullName"] == tName and VUHDO_RAID_NAMES[tName] then
  405.                     VUHDO_IS_SUSPICIOUS_ROSTER = true;
  406.                 end
  407.  
  408.                 -- ensure not to overwrite a player name with a pet's identical name
  409.                 if not VUHDO_RAID_NAMES[tName] or not tIsPet then
  410.                     VUHDO_RAID_NAMES[tName] = aUnit;
  411.                 end
  412.             end
  413.  
  414.         elseif tInfo then
  415.             tIsAfk, tInfo["connected"], tIsDcChange = VUHDO_updateAfkDc(aUnit);
  416.             tInfo["dead"] = tIsDead;
  417.  
  418.             if tIsDcChange then VUHDO_updateBouquetsForEvent(aUnit, 19); end-- VUHDO_UPDATE_DC
  419.  
  420.             if 2 == aMode then -- VUHDO_UPDATE_HEALTH
  421.                 tNewHealth = UnitHealth(aUnit);
  422.                 if not tIsDead and tInfo["health"] > 0 then
  423.                     tInfo["lifeLossPerc"] = tNewHealth / tInfo["health"];
  424.                 end
  425.  
  426.                 tInfo["health"] = tNewHealth;
  427.  
  428.                 if tInfo["dead"] ~= tIsDead then
  429.                     if not tIsDead then
  430.                         tInfo["healthmax"] = UnitHealthMax(aUnit);
  431.                     end
  432.                     tInfo["dead"] = tIsDead;
  433.                     VUHDO_updateHealthBarsFor(aUnit, 10); -- VUHDO_UPDATE_ALIVE
  434.                     VUHDO_updateBouquetsForEvent(aUnit, 10); -- VUHDO_UPDATE_ALIVE
  435.                 end
  436.  
  437.             elseif 3 == aMode then -- VUHDO_UPDATE_HEALTH_MAX
  438.                 tInfo["dead"] = tIsDead;
  439.                 tInfo["healthmax"] = UnitHealthMax(aUnit);
  440.                 tInfo["sortMaxHp"] = VUHDO_getUnitSortMaxHp(aUnit);
  441.  
  442.                 if IsAddOnLoaded("Isboxer" ) then
  443.                     for value, data in pairs( isboxer.CharacterSet ) do
  444.                         if value == "Members" then
  445.                             for slot, isboxerCharacterName in pairs( data ) do
  446.                                 isboxerCharacterName = gsub(isboxerCharacterName, "%-[^|]+", "")
  447.                                 if tInfo["name"] == isboxerCharacterName then tInfo["sortMaxHp"] = tInfo["sortMaxHp"]+(1000000*slot); end
  448.                             end
  449.                         end        
  450.                     end
  451.                 end
  452.  
  453.             elseif 6 == aMode then -- VUHDO_UPDATE_AFK
  454.                 tInfo["afk"] = tIsAfk;
  455.             end
  456.         end
  457.     end
  458. end
  459. local VUHDO_setHealth = VUHDO_setHealth;
  460.  
  461.  
  462.  
  463. --
  464. local function VUHDO_setHealthSafe(aUnit, aMode)
  465.     if UnitExists(aUnit) then VUHDO_setHealth(aUnit, aMode); end
  466. end
  467.  
  468.  
  469.  
  470. -- Callback for UNIT_HEALTH / UNIT_MAXHEALTH events
  471. local tOwner;
  472. local tIsPet;
  473. function VUHDO_updateHealth(aUnit, aMode)
  474.     -- as of patch 7.1 we are seeing empty units on health related events
  475.     if not aUnit then
  476.         return;
  477.     end
  478.  
  479.     tIsPet = VUHDO_RAID[aUnit] and VUHDO_RAID[aUnit]["isPet"];
  480.  
  481.     if not tIsPet or VUHDO_INTERNAL_TOGGLES[26] then -- VUHDO_UPDATE_PETS  -- Enth�lt nur Pets als eigene Balken, vehicles werden ?ber owner dargestellt s.unten
  482.         VUHDO_setHealth(aUnit, aMode);
  483.         VUHDO_updateHealthBarsFor(aUnit, aMode);
  484.     end
  485.  
  486.     if tIsPet then -- Vehikel?
  487.         tOwner = VUHDO_RAID[aUnit]["ownerUnit"];
  488.         -- tOwner may not be present when leaving a vehicle
  489.         if VUHDO_RAID[tOwner] and VUHDO_RAID[tOwner]["isVehicle"] then
  490.             VUHDO_setHealth(tOwner, aMode);
  491.             VUHDO_updateHealthBarsFor(tOwner, aMode);
  492.         end
  493.     end
  494.  
  495.     if 1 ~= sCurrentMode -- VUHDO_MODE_NEUTRAL
  496.         and (2 == aMode or 3 == aMode) then -- VUHDO_UPDATE_HEALTH -- VUHDO_UPDATE_HEALTH_MAX
  497.         -- Remove old emergencies
  498.         VUHDO_FORCE_RESET = true;
  499.         for tUnit, _ in pairs(VUHDO_EMERGENCIES) do
  500.             VUHDO_updateHealthBarsFor(tUnit, 11); -- VUHDO_UPDATE_EMERGENCY
  501.         end
  502.         VUHDO_sortEmergencies();
  503.         -- Set new Emergencies
  504.         VUHDO_FORCE_RESET = false;
  505.         for tUnit, _ in pairs(VUHDO_EMERGENCIES) do
  506.             VUHDO_updateHealthBarsFor(tUnit, 11); -- VUHDO_UPDATE_EMERGENCY
  507.         end
  508.     end
  509. end
  510.  
  511.  
  512.  
  513. --
  514. local tIcon;
  515. function VUHDO_updateAllRaidTargetIndices()
  516.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  517.         tIcon = GetRaidTargetIndex(tUnit);
  518.         if tInfo["raidIcon"] ~= tIcon then
  519.             tInfo["raidIcon"] = tIcon;
  520.             VUHDO_updateBouquetsForEvent(tUnit, 24); -- VUHDO_UPDATE_RAID_TARGET
  521.         end
  522.     end
  523. end
  524.  
  525.  
  526.  
  527. -- Add to groups 1-8
  528. local function VUHDO_addUnitToGroup(aUnit, aGroupNum)
  529.     if "player" ~= aUnit or not VUHDO_CONFIG["OMIT_SELF"] then
  530.         if not VUHDO_CONFIG["OMIT_OWN_GROUP"] or aGroupNum ~= VUHDO_PLAYER_GROUP then
  531.             tinsert(VUHDO_GROUPS[aGroupNum] or {}, aUnit);
  532.         end
  533.  
  534.         if VUHDO_PLAYER_GROUP == aGroupNum then tinsert(VUHDO_GROUPS[10], aUnit); end -- VUHDO_ID_GROUP_OWN
  535.     end
  536. end
  537.  
  538.  
  539.  
  540. --
  541. local function VUHDO_addUnitToClass(aUnit, aClassId)
  542.     if ("player" ~= aUnit or not VUHDO_CONFIG["OMIT_SELF"]) and aClassId then
  543.         tinsert(VUHDO_GROUPS[aClassId], aUnit);
  544.     end
  545. end
  546.  
  547.  
  548.  
  549. --
  550. local function VUHDO_removeUnitFromRaidGroups(aUnit)
  551.     for tModelId, tAllUnits in pairs(VUHDO_GROUPS) do
  552.         if tModelId ~= 41 and tModelId ~= 42 and tModelId ~= 43 and tModelId ~= 44 then  -- VUHDO_ID_MAINTANKS -- VUHDO_ID_PRIVATE_TANKS -- VUHDO_ID_MAIN_ASSISTS -- VUHDO_ID_BOSSES
  553.             for tIndex, tUnit in pairs(tAllUnits) do
  554.                 if tUnit == aUnit then tremove(tAllUnits, tIndex); end
  555.             end
  556.         end
  557.     end
  558. end
  559.  
  560.  
  561.  
  562. --
  563. local function VUHDO_removeSpecialFromAllRaidGroups()
  564.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  565.         if VUHDO_CONFIG["OMIT_MAIN_TANKS"] and VUHDO_isModelConfigured(41) and VUHDO_isUnitInModelIterative(tUnit, 41) then -- VUHDO_ID_MAINTANKS
  566.             VUHDO_removeUnitFromRaidGroups(tUnit); -- VUHDO_ID_MAINTANKS
  567.         elseif VUHDO_CONFIG["OMIT_PLAYER_TARGETS"] and VUHDO_isModelConfigured(42) and VUHDO_isUnitInModelIterative(tUnit, 42) then -- VUHDO_ID_PRIVATE_TANKS
  568.             VUHDO_removeUnitFromRaidGroups(tUnit); -- VUHDO_ID_PRIVATE_TANKS
  569.         elseif VUHDO_CONFIG["OMIT_MAIN_ASSIST"] and VUHDO_isModelConfigured(43) and VUHDO_isUnitInModelIterative(tUnit, 43) then -- VUHDO_ID_MAIN_ASSISTS
  570.             VUHDO_removeUnitFromRaidGroups(tUnit); -- VUHDO_ID_MAIN_ASSISTS
  571.         elseif VUHDO_isModelConfigured(44) and VUHDO_isUnitInModelIterative(tUnit, 44) then -- VUHDO_ID_BOSSES
  572.             VUHDO_removeUnitFromRaidGroups(tUnit); -- VUHDO_ID_BOSSES
  573.         end
  574.     end
  575. end
  576.  
  577.  
  578.  
  579. --
  580. local tRole;
  581. local function VUHDO_addUnitToSpecial(aUnit)
  582.     if VUHDO_CONFIG["OMIT_DFT_MTS"] and "TANK" == (UnitGroupRolesAssigned(aUnit)) then
  583.         tinsert(VUHDO_GROUPS[41], aUnit); -- VUHDO_ID_MAINTANKS
  584.         return;
  585.     end
  586.  
  587.     if not IsInRaid() then return; end
  588.  
  589.     _, _, _, _, _, _, _, _, _, tRole = GetRaidRosterInfo(VUHDO_RAID[aUnit]["number"]);
  590.     if "MAINTANK" == tRole then tinsert(VUHDO_GROUPS[41], aUnit); -- VUHDO_ID_MAINTANKS
  591.     elseif "MAINASSIST" == tRole then tinsert(VUHDO_GROUPS[43], aUnit); end -- VUHDO_ID_MAIN_ASSISTS
  592. end
  593.  
  594.  
  595.  
  596. --
  597. local function VUHDO_addUnitToCtraMainTanks()
  598.     local tUnit;
  599.  
  600.     for tCnt = 1, 8 do -- VUHDO_MAX_MTS
  601.         tUnit = VUHDO_MAINTANKS[tCnt];
  602.         if tUnit then VUHDO_tableUniqueAdd(VUHDO_GROUPS[41], tUnit); end -- VUHDO_ID_MAINTANKS
  603.     end
  604. end
  605.  
  606.  
  607.  
  608. --
  609. local function VUHDO_addUnitToPrivateTanks()
  610.     if not VUHDO_CONFIG["OMIT_TARGET"] then tinsert(VUHDO_GROUPS[42], "target"); end -- VUHDO_ID_PRIVATE_TANKS
  611.     if not VUHDO_CONFIG["OMIT_FOCUS"] then tinsert(VUHDO_GROUPS[42], "focus"); end -- VUHDO_ID_PRIVATE_TANKS
  612.  
  613.     local tUnit;
  614.     for tName, _ in pairs(VUHDO_PLAYER_TARGETS) do
  615.         tUnit = VUHDO_RAID_NAMES[tName];
  616.         if tUnit then VUHDO_tableUniqueAdd(VUHDO_GROUPS[42], tUnit); -- VUHDO_ID_PRIVATE_TANKS
  617.         else VUHDO_PLAYER_TARGETS[tName] = nil; end
  618.     end
  619. end
  620.  
  621.  
  622.  
  623. --
  624. local function VUHDO_addUnitToBosses()
  625.     for bossUnitId, _ in pairs(VUHDO_BOSS_UNITS) do
  626.         VUHDO_tableUniqueAdd(VUHDO_GROUPS[44], bossUnitId); -- VUHDO_ID_BOSSES
  627.     end
  628. end
  629.  
  630.  
  631.  
  632. --
  633. local tVehicleInfo = { ["isVehicle"] = true };
  634. local function VUHDO_addUnitToPets(aPetUnit)
  635.     if (VUHDO_RAID[VUHDO_RAID[aPetUnit]["ownerUnit"]] or tVehicleInfo)["isVehicle"] then return; end
  636.     tinsert(VUHDO_GROUPS[40], aPetUnit); -- VUHDO_ID_PETS
  637. end
  638.  
  639.  
  640.  
  641. --
  642. local tRole;
  643. local function VUHDO_addUnitToRole(aUnit)
  644.     if "player" == aUnit and VUHDO_CONFIG["OMIT_SELF"] then return; end
  645.  
  646.     tRole = VUHDO_RAID[aUnit]["role"] or 62; -- -- VUHDO_ID_RANGED_DAMAGE
  647.  
  648.     tinsert(VUHDO_GROUPS[tRole], aUnit);
  649.     if tRole == 63 or tRole == 62 then tinsert(VUHDO_GROUPS[51], aUnit); -- VUHDO_ID_RANGED_HEAL -- VUHDO_ID_RANGED_DAMAGE -- VUHDO_ID_RANGED
  650.     elseif tRole == 61 or tRole == 60 then tinsert(VUHDO_GROUPS[50], aUnit); end -- VUHDO_ID_MELEE_DAMAGE -- VUHDO_ID_MELEE_TANK -- VUHDO_ID_MELEE
  651. end
  652.  
  653.  
  654.  
  655. --
  656. local function VUHDO_addUnitToVehicles(aUnit)
  657.     if VUHDO_RAID[aUnit]["petUnit"] then tinsert(VUHDO_GROUPS[70], VUHDO_RAID[aUnit]["petUnit"]); end -- VUHDO_ID_VEHICLES
  658. end
  659.  
  660.  
  661.  
  662. --
  663. local function VUHDO_updateGroupArrays(anWasMacroRestore)
  664.     -- Get an empty array for each group
  665.     for tType, tTypeMembers in pairs(VUHDO_ID_TYPE_MEMBERS) do
  666.         for _, tMember in pairs(tTypeMembers) do
  667.             if not VUHDO_GROUPS[tMember] then VUHDO_GROUPS[tMember] = { };
  668.             else twipe(VUHDO_GROUPS[tMember]); end
  669.         end
  670.     end
  671.  
  672.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  673.         if not tInfo["isPet"] then
  674.             if not VUHDO_isSpecialUnit(tUnit) then
  675.                 VUHDO_addUnitToGroup(tUnit, tInfo["group"]);
  676.                 VUHDO_addUnitToClass(tUnit, tInfo["classId"]);
  677.                 VUHDO_addUnitToVehicles(tUnit);
  678.                 VUHDO_addUnitToSpecial(tUnit);
  679.             end
  680.         else
  681.             VUHDO_addUnitToPets(tUnit);
  682.         end
  683.     end
  684.     VUHDO_GROUPS[80][1] = "player"; -- VUHDO_ID_SELF
  685.     VUHDO_GROUPS[81][1] = "pet"; -- VUHDO_ID_SELF_PET
  686.     VUHDO_GROUPS[82][1] = "target"; -- VUHDO_ID_TARGET
  687.     VUHDO_GROUPS[83][1] = "focus"; -- VUHDO_ID_FOCUS
  688.  
  689.     VUHDO_addUnitToCtraMainTanks();
  690.     VUHDO_addUnitToPrivateTanks();
  691.     VUHDO_addUnitToBosses();
  692.  
  693.     -- Need MTs for role estimation
  694.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  695.         if not VUHDO_isSpecialUnit(tUnit) and not tInfo["isPet"] then
  696.             VUHDO_addUnitToRole(tUnit);
  697.         end
  698.     end
  699.     if not anWasMacroRestore then
  700.         VUHDO_removeSpecialFromAllRaidGroups();
  701.     end
  702.     VUHDO_initDynamicPanelModels();
  703. end
  704.  
  705.  
  706.  
  707. -- Uniquely buffer all units defined in a panel
  708. local tPanelUnits = { };
  709. local tHasVehicles;
  710. local tVehicleUnit;
  711. local function VUHDO_updateAllPanelUnits()
  712.  
  713.     VUHDO_resetRemoveFromRaidGroupsCache();
  714.  
  715.     for tPanelNum = 1, 10 do -- VUHDO_MAX_PANELS
  716.         twipe(VUHDO_PANEL_UNITS[tPanelNum]);
  717.  
  718.         if VUHDO_PANEL_MODELS[tPanelNum] then
  719.             tHasVehicles = VUHDO_isModelInPanel(tPanelNum, 70); -- VUHDO_ID_VEHICLES
  720.             twipe(tPanelUnits);
  721.             for tUnit, _ in pairs(VUHDO_RAID) do
  722.                 if VUHDO_isUnitInPanel(tPanelNum, tUnit) then tPanelUnits[tUnit] = tUnit; end
  723.  
  724.                 if tHasVehicles and not VUHDO_RAID[tUnit]["isPet"] then
  725.                     tVehicleUnit = VUHDO_RAID[tUnit]["petUnit"];
  726.                     if tVehicleUnit then tPanelUnits[tVehicleUnit] = tVehicleUnit end -- e.g. "focus", "target"
  727.                 end
  728.             end
  729.  
  730.             if VUHDO_isModelInPanel(tPanelNum, 42) then -- VUHDO_ID_PRIVATE_TANKS
  731.                 if not VUHDO_CONFIG["OMIT_TARGET"] then tPanelUnits["target"] = "target"; end
  732.                 if not VUHDO_CONFIG["OMIT_FOCUS"] then tPanelUnits["focus"] = "focus"; end
  733.             end
  734.  
  735.             for _, tUnit in pairs(tPanelUnits) do
  736.                 tinsert(VUHDO_PANEL_UNITS[tPanelNum], tUnit);
  737.             end
  738.         end
  739.     end
  740. end
  741.  
  742.  
  743.  
  744. --
  745. local function VUHDO_updateAllGuids()
  746.     twipe(VUHDO_RAID_GUIDS);
  747.     for tUnit, _ in pairs(VUHDO_RAID) do
  748.         if tUnit ~= "focus" and tUnit ~= "target" then
  749.             VUHDO_RAID_GUIDS[UnitGUID(tUnit) or 0] = tUnit;
  750.         end
  751.     end
  752. end
  753.  
  754.  
  755.  
  756. --
  757. local function VUHDO_convertMainTanks()
  758.     -- Discard deprecated
  759.     for tCnt = 1, 8 do -- VUHDO_MAX_MTS
  760.         if not VUHDO_RAID_NAMES[VUHDO_MAINTANK_NAMES[tCnt] or "*"] then
  761.             VUHDO_MAINTANK_NAMES[tCnt] = nil;
  762.         end
  763.     end
  764.     -- Convert to units instead of names
  765.     twipe(VUHDO_MAINTANKS);
  766.     for tCnt, tName in pairs(VUHDO_MAINTANK_NAMES) do
  767.         VUHDO_MAINTANKS[tCnt] = VUHDO_RAID_NAMES[tName];
  768.     end
  769. end
  770.  
  771.  
  772.  
  773. --
  774. local function VUHDO_createClusterUnits()
  775.     twipe(VUHDO_CLUSTER_BASE_RAID);
  776.     VUHDO_resetClusterCoordDeltas();
  777.  
  778.     for tUnit, tInfo in pairs(VUHDO_RAID) do
  779.         if not tInfo["isPet"] and "focus" ~= tUnit and "target" ~= tUnit then
  780.             VUHDO_CLUSTER_BASE_RAID[#VUHDO_CLUSTER_BASE_RAID + 1] = tInfo;
  781.         end
  782.     end
  783. end
  784.  
  785.  
  786.  
  787. --
  788. -- Reload all raid members into the raid array e.g. in case of raid roster change
  789. function VUHDO_reloadRaidMembers()
  790.     local tPlayer;
  791.     local tMaxMembers;
  792.     local tUnit, tPetUnit;
  793.     local tWasRestored = false;
  794.  
  795.     VUHDO_IS_SUSPICIOUS_ROSTER = false;
  796.  
  797.     if GetNumGroupMembers() == 0 and not UnitExists("party1") and not sIsRestoredAfterDc then
  798.         VUHDO_IN_COMBAT_RELOG = true;
  799.         tWasRestored = VUHDO_buildRaidFromMacro();
  800.         VUHDO_updateAllRaidNames();
  801.         if (tWasRestored) then
  802.             VUHDO_normalRaidReload(true);
  803.         end
  804.         sIsRestoredAfterDc = true;
  805.  
  806.     elseif VUHDO_isConfigDemoUsers() then
  807.         VUHDO_demoSetupResetUsers();
  808.         VUHDO_reloadRaidDemoUsers();
  809.         VUHDO_updateAllRaidNames();
  810.  
  811.     else
  812.         VUHDO_PLAYER_RAID_ID = VUHDO_getPlayerRaidUnit();
  813.         VUHDO_IN_COMBAT_RELOG = false;
  814.         sIsRestoredAfterDc = true;
  815.         tUnit, tPetUnit = VUHDO_getUnitIds();
  816.  
  817.         tMaxMembers = ("raid" == tUnit) and GetNumGroupMembers() or ("party" == tUnit) and 4 or 0;
  818.  
  819.         twipe(VUHDO_RAID);
  820.         twipe(VUHDO_RAID_NAMES);
  821.  
  822.         for tCnt = 1, tMaxMembers do
  823.             tPlayer = tUnit .. tCnt;
  824.             if UnitExists(tPlayer) and tPlayer ~= VUHDO_PLAYER_RAID_ID then
  825.                 VUHDO_setHealth(tPlayer, 1); -- VUHDO_UPDATE_ALL
  826.                 VUHDO_setHealthSafe(tPetUnit .. tCnt, 1); -- VUHDO_UPDATE_ALL
  827.             end
  828.         end
  829.  
  830.         VUHDO_setHealthSafe("player", 1); -- VUHDO_UPDATE_ALL
  831.         VUHDO_setHealthSafe("pet", 1); -- VUHDO_UPDATE_ALL
  832.         VUHDO_setHealthSafe("focus", 1); -- VUHDO_UPDATE_ALL
  833.  
  834.         if VUHDO_INTERNAL_TOGGLES[27] then -- VUHDO_UPDATE_PLAYER_TARGET
  835.             VUHDO_setHealthSafe("target", 1); -- VUHDO_UPDATE_ALL
  836.         end
  837.  
  838.         for bossUnitId, _ in pairs(VUHDO_BOSS_UNITS) do
  839.             if UnitExists(bossUnitId) then
  840.                 VUHDO_setHealth(bossUnitId, 1); -- VUHDO_UPDATE_ALL
  841.             else
  842.                 -- FIXME: find a more efficient way to trigger boss removal
  843.                 VUHDO_removeHots(bossUnitId);
  844.                 VUHDO_resetDebuffsFor(bossUnitId);
  845.                 VUHDO_removeAllDebuffIcons(bossUnitId);
  846.                 VUHDO_updateTargetBars(bossUnitId);
  847.                 table.wipe(VUHDO_RAID[bossUnitId] or tEmptyInfo);
  848.                 VUHDO_RAID[bossUnitId] = nil;
  849.  
  850.                 VUHDO_updateHealthBarsFor(bossUnitId, 1); -- VUHDO_UPDATE_ALL
  851.                 VUHDO_initEventBouquetsFor(bossUnitId);
  852.             end
  853.         end
  854.  
  855.         VUHDO_TIMERS["MIRROR_TO_MACRO"] = 8;
  856.     end
  857.  
  858.     VUHDO_PLAYER_GROUP = VUHDO_getUnitGroup(VUHDO_PLAYER_RAID_ID, false);
  859.  
  860.     VUHDO_trimInspected();
  861.     VUHDO_convertMainTanks();
  862.     VUHDO_updateGroupArrays(tWasRestored);
  863.     VUHDO_updateAllPanelUnits();
  864.     VUHDO_updateAllGuids();
  865.     VUHDO_updateBuffRaidGroup();
  866.     VUHDO_updateBuffPanel();
  867.  
  868.     if sCurrentMode ~= 1 then VUHDO_sortEmergencies(); end -- VUHDO_MODE_NEUTRAL
  869.  
  870.     VUHDO_createClusterUnits();
  871.  
  872.     if VUHDO_IS_SUSPICIOUS_ROSTER then VUHDO_normalRaidReload(); end
  873. end
  874.  
  875.  
  876.  
  877. --
  878. local tPlayer;
  879. local tMaxMembers;
  880. local tUnitType = "foo";
  881. local tPetUnitType;
  882. local tInfo;
  883. local tIsDcChange;
  884. local tName, tRealm;
  885. local tOldUnitType;
  886. local tPet;
  887. function VUHDO_refreshRaidMembers()
  888.     VUHDO_PLAYER_RAID_ID = VUHDO_getPlayerRaidUnit();
  889.     VUHDO_IN_COMBAT_RELOG = false;
  890.  
  891.     tOldUnitType = tUnitType;
  892.     tUnitType, tPetUnitType = VUHDO_getUnitIds();
  893.  
  894.     tMaxMembers = ("raid" == tUnitType) and 40 or ("party" == tUnitType) and 4 or 0;
  895.  
  896.     for tCnt = 1, tMaxMembers do
  897.         tPlayer = tUnitType .. tCnt;
  898.  
  899.         if UnitExists(tPlayer) and tPlayer ~= VUHDO_PLAYER_RAID_ID then
  900.             tInfo = VUHDO_RAID[tPlayer];
  901.             if not tInfo or VUHDO_RAID_GUIDS[UnitGUID(tPlayer)] ~= tPlayer then
  902.                 --VUHDO_xMsg("VUHDO_refreshRaidMembers", "VUHDO_setHealth", tPlayer or "no player", tInfo and "in raid" or "not in raid", VUHDO_RAID_GUIDS[UnitGUID(tPlayer)] or "no raid guid");
  903.                 VUHDO_setHealth(tPlayer, 1); -- VUHDO_UPDATE_ALL
  904.             else
  905.                 tInfo["group"] = VUHDO_getUnitGroup(tPlayer, false);
  906.  
  907.                 tInfo["isVehicle"] = UnitHasVehicleUI(tPlayer);
  908.                 if ( tInfo["isVehicle"] ) then
  909.                     local tRaidId = UnitInRaid(tPlayer);
  910.                    
  911.                     if ( tRaidId and not UnitTargetsVehicleInRaidUI(tPlayer) ) then
  912.                         tInfo["isVehicle"] = false;
  913.                     end
  914.                 end
  915.  
  916.                 tInfo["afk"], tInfo["connected"], tIsDcChange = VUHDO_updateAfkDc(tPlayer);
  917.  
  918.                 if tIsDcChange then
  919.                     VUHDO_updateBouquetsForEvent(tPlayer, 19); -- VUHDO_UPDATE_DC
  920.                 end
  921.                 VUHDO_setHealthSafe(tPetUnitType .. tCnt, 1); -- VUHDO_UPDATE_ALL
  922.             end
  923.  
  924.         elseif VUHDO_RAID[tPlayer] then
  925.             VUHDO_RAID[tPlayer]["connected"] = false;
  926.             tPet = VUHDO_RAID[tPlayer]["petUnit"];
  927.             if VUHDO_RAID[tPet] then
  928.                 VUHDO_RAID[tPet]["connected"] = false;
  929.             end
  930.         end
  931.     end
  932.  
  933.     VUHDO_setHealthSafe("player", 1); -- VUHDO_UPDATE_ALL
  934.     VUHDO_setHealthSafe("pet", 1); -- VUHDO_UPDATE_ALL
  935.     VUHDO_setHealthSafe("focus", 1); -- VUHDO_UPDATE_ALL
  936.     if VUHDO_INTERNAL_TOGGLES[27] then -- VUHDO_UPDATE_PLAYER_TARGET
  937.         VUHDO_setHealthSafe("target", 1); -- VUHDO_UPDATE_ALL
  938.     end
  939.  
  940.     for bossUnitId, _ in pairs(VUHDO_BOSS_UNITS) do
  941.         if UnitExists(bossUnitId) then -- and UnitIsFriend("player", bossUnitId) then
  942.             tInfo = VUHDO_RAID[bossUnitId];
  943.  
  944.             if not tInfo or VUHDO_RAID_GUIDS[UnitGUID(bossUnitId)] ~= bossUnitId then
  945.                 VUHDO_setHealth(bossUnitId, 1); -- VUHDO_UPDATE_ALL
  946.             else
  947.                 tInfo["group"] = VUHDO_getUnitGroup(bossUnitId, false);
  948.                 tInfo["isVehicle"] = UnitHasVehicleUI(bossUnitId);
  949.  
  950.                 tInfo["afk"] = false;
  951.                 tInfo["connected"] = true;
  952.             end
  953.         else
  954.             -- FIXME: find a more efficient way to trigger boss removal
  955.             VUHDO_removeHots(bossUnitId);
  956.             VUHDO_resetDebuffsFor(bossUnitId);
  957.             VUHDO_removeAllDebuffIcons(bossUnitId);
  958.             VUHDO_updateTargetBars(bossUnitId);
  959.             table.wipe(VUHDO_RAID[bossUnitId] or tEmptyInfo);
  960.             VUHDO_RAID[bossUnitId] = nil;
  961.  
  962.             VUHDO_updateHealthBarsFor(bossUnitId, 1); -- VUHDO_UPDATE_ALL
  963.             VUHDO_initEventBouquetsFor(bossUnitId);
  964.         end
  965.     end
  966.  
  967.     VUHDO_PLAYER_GROUP = VUHDO_getUnitGroup(VUHDO_PLAYER_RAID_ID, false);
  968.  
  969.     VUHDO_updateAllRaidNames();
  970.     VUHDO_trimInspected();
  971.     VUHDO_convertMainTanks();
  972.     VUHDO_updateGroupArrays(false);
  973.     VUHDO_updateAllPanelUnits();
  974.     VUHDO_updateAllGuids();
  975.     VUHDO_updateBuffRaidGroup();
  976.     if sCurrentMode ~= 1 then VUHDO_sortEmergencies(); end -- VUHDO_MODE_NEUTRAL
  977.     VUHDO_createClusterUnits();
  978. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top