vanilla-wow-addons – Rev 1
?pathlinks?
--[[------------------------------ Development stuff start ----------------------
You schould NOT mess with this stuff you can totally kill the mod here if you don't
know what your doing, and there is NOTHING to be gained
]]--
--I do a lot (most) of development outside of WOW so here is a switch
SW_DEV_INWOW = true;
-- a util to create junk msgs to test against
SW_DEV_CREATE_JUNK_STRINGS = true;
-- just handy to have
if SW_DEV_INWOW then
SW_DEV_CREATE_JUNK_STRINGS = false;
end
-- amount of junk do produce per regex
SW_DEV_ITEMS_PER_REGEX = 1;
-- dummy event all registered regEx will be here
SW_DEV_EVENTDUMMY = "EVENTDUMMY";
SW_DECURSEDUMMY = "DECURSEDUMMY";
--SW_DECEV = {};
SW_SpellIDLookUp = {};
-- if outside of wow add stuff here to be loaded
if not SW_DEV_INWOW then
function GetLocale()
return "deDE";
end
dofile("GlobToUseDs.lua"); -- this is not distributet with the mod (its a stripped down GlobalStrings.lua from bliz)
--dofile("GlobalStrings-CH-xx.lua"); -- just a chinese version (core seems to work but not 100% sure)
dofile("SW_DefaultMap.lua");
SW_Map = SW_DefaultMap;
dofile("console.lua");
dofile("neutral.lua");
--dofile("localization.DE.lua");
dofile("init.lua");
SW_DEV_FINDMATCH = {};
SW_DEV_FINDCOLL = {};
if SW_DEV_CREATE_JUNK_STRINGS then
math.randomseed(os.time());
SW_DEV_JUNK_STRINGS ={};
end
arg1="";
end
--added 1.4
--used to skip code while in "dev mode" this should always be true in a release
SW_LIVE_MODE = true;
-------------------------------- Development stuff END ----------------------
-- table to look up localized class names (lookup built automtically)
SW_ClassNames = {
["DRUID"] = "",
["HUNTER"] = "",
["MAGE"] = "",
["PALADIN"] = "",
["PRIEST"] = "",
["ROGUE"] = "",
["SHAMAN"] = "",
["WARLOCK"] = "",
["WARRIOR"] = "",
};
-- the lookup table with regex generated from Blizzards global vars
-- for adding vars add them in init.lua SW_CreateRegexFromGlobals()
SW_RegEx_Lookup = {};
-- this maps events to regular expressions
-- to chage this mapping see init.lua SW_CreateEventRegexMap()
SW_EventRegexMap ={};
-- similar to SW_EventRegexMap but only with VSENVIRONMENTALDAMAGE_XXX
-- this is only checked if nothing "fit" SW_EventRegexMap
SW_EventRegexMapEnviro = {};
-- info with stuff that happened at startup
-- if in the end all was ok it will be nil
-- else it has some info to track down problems
SW_StartupLog = {};
-- this tracks events we lsten to but dont have a regex for
SW_NA_Msgs = {};
-- this is used to block the Fallback feature
-- if no regex was found for an event, the event is blocked from updating itself
-- else it would always go through all events in the event dummy
SW_Fallback_Block = {};
-- resist stuff disabled
SW_CheckForAbsorbs = true; -- does etra check for ending (123 resisted) or (234 absorbed)etc
SW_OnlyResists = false; --if previeous is true it only does this check for resist (most interesting)
--v 0.95 added SW_S_* to saved vars
-- table with infos
SW_S_Details = {};
-- table with heal map (who/who) info
SW_S_Healed = {};
--1.3.0 Table with spell and mana info this person casted
SW_S_SpellInfo = {};
--1.3.0 Table with mana info dmg, heal and total mana used
SW_S_ManaUsage = {};
-- "Friends" Table either self, group or raid
-- used to sperate any recorded info from people "in group"
SW_Friends = {};
-- pet to owner lookup
--SW_Pets = {}; removed 1.5 old pet mech
-- 1.5 extended pet info
SW_PetInfo = {};
SW_PetInfo["OWNER_PET"] = {};
SW_PetInfo["PET_OWNER"] = {};
--1.3.1 holds time info for DPS
--1.3.2 had to change this again time and DPS dmg are not saved anymore across sessions
SW_CombatTime = 0;
SW_CombatTimeInfo = {};
SW_DPS_Dmg =0;
SW_CombatTimeCounter =0;
--settings Table
SW_Settings = {};
-- its the player name we would look it up a LOT
SW_SELF_STRING= "";
-- the "Event Channel" - we need it a LOT
SW_Event_Channel =nil;
SW_EI_ALLOFF = false;
-- 1.5.3 used for colors of the title bars and buttons in them
SW_Registerd_BF_Titles = {};
SW_Registered_BF_TitleButtons = {};
SW_DummyColor = {1,1,1,1};
function SW_CreateSpellIDLookup()
--SW_SpellIDLookUp = {};
for i,v in ipairs(SW_Spellnames) do
SW_SpellIDLookUp[v] = i;
end
end
--------------------- START section GETINFO ---------------------------
local function SW_g1(doMe, withInfo)
_,_,v1 = string.find(doMe, withInfo["r"])
if v1 == nil then return nil; end
return {v1};
end
local function SW_g2(doMe, withInfo)
_,_,v1, v2 = string.find(doMe, withInfo["r"])
if v2 == nil then return nil; end
return {v1, v2};
end
local function SW_g3(doMe, withInfo)
_,_,v1, v2, v3 = string.find(doMe, withInfo["r"])
if v3 == nil then return nil; end
return {v1, v2, v3};
end
local function SW_g4(doMe, withInfo)
_,_,v1, v2, v3, v4 = string.find(doMe, withInfo["r"])
if v4 == nil then return nil; end
return {v1, v2, v3, v4};
end
local function SW_g5(doMe, withInfo)
_,_,v1, v2, v3, v4, v5 = string.find(doMe, withInfo["r"])
if v5 == nil then return nil; end
return {v1, v2, v3, v4, v5};
end
local function SW_g6(doMe, withInfo)
_,_,v1, v2, v3, v4, v5, v6 = string.find(doMe, withInfo["r"])
if v6 == nil then return nil; end
return {v1, v2, v3, v4, v5, v6};
end
local function SW_g7(doMe, withInfo)
_,_,v1, v2, v3, v4, v5, v6, v7 = string.find(doMe, withInfo["r"])
if v7 == nil then return nil; end
return {v1, v2, v3, v4, v5, v6, v7};
end
function SW_g8(doMe, withInfo)
_,_,v1, v2, v3, v4, v5, v6, v7, v8 = string.find(doMe, withInfo["r"])
if v8 == nil then return nil; end
return {v1, v2, v3, v4, v5, v6, v7, v8};
end
local function SW_g9(doMe, withInfo)
_,_,v1, v2, v3, v4, v5, v6, v7, v8, v9 = string.find(doMe, withInfo["r"])
if v9 == nil then return nil; end
return {v1, v2, v3, v4, v5, v6, v7, v8, v9};
end
-- here we resort the values via the mapping that was created during the init
local function SW_sortVals(vals, withInfo)
if vals == nil then return nil; end
local ret = {};
for k,v in pairs(withInfo["p"]) do
ret[v] = vals[k];
end
return ret;
end
local SW_MAX_ARGS = 9;
-- a functionLookup mapping # returned arguments to a specific function
local SW_Func_Lookup = {SW_g1,SW_g2,SW_g3,SW_g4,SW_g5,SW_g6,SW_g7,SW_g8,SW_g9};
-- this actually performs the search on a string
function SW_getInfo(doMe, withInfo )
-- if we don't have a function or # of captures is invlid return nil
if withInfo["r"] == nil or withInfo["i"] > SW_MAX_ARGS or withInfo["i"] < 1 then return nil; end
-- resort if we have to
if withInfo["p"] == nil then
return SW_Func_Lookup[withInfo["i"]](doMe, withInfo);
--return SW_Func_Lookup[withInfo["i"]](doMe, withInfo);
else
return SW_sortVals(SW_Func_Lookup[withInfo["i"]](doMe, withInfo), withInfo);
end
end
-- at the end of dmg messages there can be blocked absobed etc messages
--this returns the globalVarName, the value absorbed
-- TODO this isnt correct.. there can be multiple endings
function getEndingInfo(strIn)
--even do the check ?
--if not SW_CheckForAbsorbs then return nil; end --add this on a outer level
-- assumption here, abosrbs etc end with a ")" (seems to be true)
if string.sub(strIn,-1)~=")" then return nil; end
s,e = string.find(strIn, SW_RegEx_Lookup["RESIST_TRAILER"]["r"])
if s ~= nil then return "RESIST_TRAILER", SW_getInfo(strIn, SW_RegEx_Lookup["RESIST_TRAILER"])[1]; end
if SW_OnlyResists then return nil; end
s,e = string.find(strIn, SW_RegEx_Lookup["ABSORB_TRAILER"]["r"])
if s ~= nil then return "ABSORB_TRAILER", SW_getInfo(strIn, SW_RegEx_Lookup["ABSORB_TRAILER"])[1]; end
s,e = string.find(strIn, SW_RegEx_Lookup["BLOCK_TRAILER"]["r"])
if s ~= nil then return "BLOCK_TRAILER", SW_getInfo(strIn, SW_RegEx_Lookup["BLOCK_TRAILER"])[1]; end
s,e = string.find(strIn, SW_RegEx_Lookup["VULNERABLE_TRAILER"]["r"])
if s ~= nil then return "VULNERABLE_TRAILER", SW_getInfo(strIn, SW_RegEx_Lookup["VULNERABLE_TRAILER"])[1]; end
return nil;
end
--------------------- END section GETINFO ---------------------------
function SW_Stats_OnLoad()
SW_SL_Add(SW_SL["START"]);
SlashCmdList["SW_STATS"] = function(msg)
SW_SlashCommand(msg);
end
SLASH_SW_STATS1 = SW_RootSlashes[1];
SLASH_SW_STATS2 = SW_RootSlashes[2];
SW_CreateRegexFromGlobals();
SW_RegisterEvents();
end
local function SW_handleMatch(event, regExName, caps)
local re = SW_RegEx_Lookup[regExName];
local reBI= re["basicInfo"];
local from = reBI[1];
local to = reBI[2];
local what = reBI[5];
local school = reBI[6];
local tmp;
local pFrom, pFromTotal, pFromWhat, pFromSchool;
local pTo, pToWhat, pToSchool, pToRec;
local isCrit = (re["isCrit"] ~= nil);
local scrapDmg = false;
--[[ START SETUP
setup all vars from to etc
make sure the vars are initialized
--]]
if from == nil then
from = SW_PRINT_ITEM_WORLD;
else
if from == -1 then from = SW_SELF_STRING; else from = caps[from]; end
if from == nil then from = "??"; end
end
if to == nil then
to = SW_PRINT_ITEM_WORLD;
else
if to == -1 then to = SW_SELF_STRING; else to = caps[to] end
if to == nil then to = "??"; end
end
-- 1.1.0 dont count dmg from self to self
if reBI[3] then
if from == to then
scrapDmg = true;
end
--1.3.1 start dps timer
if SW_CombatTimeInfo.awaitingStart and from == SW_SELF_STRING then
SW_CombatTimeInfo.awaitingStart = false;
SW_CombatTimeInfo.awaitingEnd = true;
end
end
if what == nil then
what = SW_PRINT_ITEM_NORMAL;
else
what = caps[ reBI[5] ];
if what == nil then what = "??"; end
end
--[[ usefull for finding wrong captures
if string.find (what, "'s") then
SW_printStr("--START--");
SW_printStr(what);
SW_printStr(arg1);
SW_printStr(regExName);
SW_printStr(re[r]);
SW_DumpTable(caps);
SW_printStr("--END--");
end
--]]
if school == nil then
school = SW_PRINT_ITEM_NON_SCHOOL;
else
school = caps[school];
if school == nil then school = "??"; end
end
pFrom = SW_S_Details[from];
if pFrom == nil then
SW_S_Details[from] ={};
pFrom = SW_S_Details[from];
pFrom[SW_PRINT_ITEM_TOTAL_DONE] = {0,0}; --first = dmg; sec = heal
pFrom[SW_PRINT_ITEM_RECIEVED] = {0,0}; --first = dmg; sec = heal
pFrom[SW_PRINT_ITEM_TYPE] = {}; -- school info
end
pFromTotal = pFrom[SW_PRINT_ITEM_TOTAL_DONE];
pTo= SW_S_Details[to];
if pTo == nil then
SW_S_Details[to] = {};
pTo = SW_S_Details[to];
pTo[SW_PRINT_ITEM_TOTAL_DONE] = {0,0}; --first = dmg; sec = heal
pTo[SW_PRINT_ITEM_RECIEVED] = {0,0}; --first = dmg; sec = heal
pTo[SW_PRINT_ITEM_TYPE] = {}; -- school info
end
pToRec = pTo[SW_PRINT_ITEM_RECIEVED];
pFromWhat = pFrom[what];
if pFromWhat == nil then
pFrom[what] ={0,0,0,0,0,0,0}; --dmg, heal, maxDmg, usedcount (or tick count with dots) - 1.4.1beta2 added ,maxHeal, critcountDmg, critcountHeal
pFromWhat = pFrom[what];
end
-- this can happen now because of the sync channel
if pFrom[SW_PRINT_ITEM_TYPE] == nil then
pFrom[SW_PRINT_ITEM_TYPE] = {};
end
pFromSchool = pFrom[SW_PRINT_ITEM_TYPE][school];
if pFromSchool == nil then
pFrom[SW_PRINT_ITEM_TYPE][school] ={0,0,0,0,0,0}; --dmgDone, Donemax, usedCount, dmgRecieved, recivedMax, recievedCount
pFromSchool = pFrom[SW_PRINT_ITEM_TYPE][school];
end
-- this can happen now because of the sync channel
if pTo[SW_PRINT_ITEM_TYPE] == nil then
pTo[SW_PRINT_ITEM_TYPE] = {};
end
pToSchool = pTo[SW_PRINT_ITEM_TYPE][school];
if pToSchool == nil then
pTo[SW_PRINT_ITEM_TYPE][school] ={0,0,0,0,0,0}; --dmgDone, Donemax, usedCount, dmgRecieved, recivedMax, recievedCount
pToSchool = pTo[SW_PRINT_ITEM_TYPE][school];
end
-- END SETUP
-- count usage up by 1
pFromWhat[4] = pFromWhat[4] + 1;
-- dmg or heal ?
if reBI[3] then
local dmg = tonumber(caps[ reBI[3] ]);
if not scrapDmg and (SW_Friends[from] ~= nil or SW_PetInfo["PET_OWNER"][from] ~= nil) then
SW_RPS:validEvent();
end
if not scrapDmg then
-- added 1.5 is this a pet?
if SW_PetInfo["PET_OWNER"][from] ~= nil then
SW_HandlePetEvent(from, true, dmg, 0);
end
--1.3.2 added extra counter for dps dmg
if from == SW_SELF_STRING then
SW_DPS_Dmg = SW_DPS_Dmg + dmg;
end
pFromTotal[1] = pFromTotal[1] + dmg;
pFromWhat[1] = pFromWhat[1] + dmg;
if dmg > pFromWhat[3] then
pFromWhat[3] = dmg;
end
--1.4.1 beta 2 added
if isCrit then
pFromWhat[6] = pFromWhat[6] + 1;
end
end
-- added 1.5 is this a pet?
if SW_PetInfo["PET_OWNER"][to] ~= nil then
SW_HandlePetEvent(to, false, dmg, 0);
end
pToRec[1] = pToRec[1] + dmg;
if not scrapDmg then
pFromSchool[1] = pFromSchool[1] +dmg;
if dmg > pFromSchool[2] then
pFromSchool[2] = dmg;
end
pFromSchool[3] = pFromSchool[3] + 1;
end
pToSchool[4] = pToSchool[4] + dmg;
if dmg > pToSchool[5] then
pToSchool[5] = dmg;
end
pToSchool[6] = pToSchool[6] + 1;
elseif reBI[4] then
local heal = tonumber(caps[ reBI[4] ]);
-- added 1.5 is this a pet?
if SW_PetInfo["PET_OWNER"][from] ~= nil then
SW_HandlePetEvent(from, true, 0, heal);
end
if SW_PetInfo["PET_OWNER"][to] ~= nil then
SW_HandlePetEvent(to, false, 0, heal);
end
if SW_Friends[to] ~= nil then
--1.4.1 added nil check is this the cause of the rare error ?
-- TODO (low prio) noticed while working on 1.5 no OH count from pets as target
local info = SW_Friends[to]["UnitID"];
if info == nil then
SW_RebuildFriendList();
if SW_Friends[to] == nil or SW_Friends[to]["UnitID"] == nil then
SW_printStr("UnitHealthMax(nil) - SW FriendList rebuilt-- didn't help");
return;
end
SW_printStr("UnitHealthMax(nil) - SW FriendList rebuilt - OK");
end
info = SW_Friends[to]["UnitID"];
local num = UnitHealthMax(info) - UnitHealth(info) - heal;
if num < 0 then
num = num * (-1);
if SW_S_Healed[from] == nil then
SW_S_Healed[from] = {};
end
if SW_S_Healed[from][SW_OVERHEAL] == nil then
SW_S_Healed[from][SW_OVERHEAL] = 0;
end
SW_S_Healed[from][SW_OVERHEAL] = SW_S_Healed[from][SW_OVERHEAL] + num;
--SW_printStr("Over Heal in cast from "..from.." to "..to.." "..num);
end
end
pFromTotal[2] = pFromTotal[2] + heal;
pFromWhat[2] = pFromWhat[2] + heal;
if heal > pFromWhat[5] then
pFromWhat[5] = heal;
end
--1.4.1 beta 2 added
if isCrit then
pFromWhat[7] = pFromWhat[7] + 1;
end
pToRec[2] = pToRec[2] + heal;
-- heal map
if SW_S_Healed[from] == nil then
SW_S_Healed[from] = {};
SW_S_Healed[from][to] = 0;
else
if SW_S_Healed[from][to] == nil then
SW_S_Healed[from][to] = 0;
end
end
SW_S_Healed[from][to] = SW_S_Healed[from][to] + heal;
end
if SW_EI_ALLOFF then return; end
--[[ --]]
if SW_Settings["EI_ShowEvent"] then
SW_Event_Channel:AddMessage(GREEN_FONT_COLOR_CODE..event.."->"..regExName);
end
if SW_Settings["EI_ShowRegEx"] then
SW_Event_Channel:AddMessage(LIGHTYELLOW_FONT_COLOR_CODE..SW_RegEx_Lookup[regExName]["r"]);
end
if SW_Settings["EI_ShowOrigStr"] then
SW_Event_Channel:AddMessage(arg1);
end
if SW_Settings["EI_ShowMatch"] then
if from == nil then
from = "?";
end
if to == nil then
to="?";
end
local sOut = string.format(SW_PRINT_INFO_FROMTO, from, to);
if reBI[3] then
if caps[ reBI[3] ] == nil then
caps[ reBI[3] ] = "??";
end
if scrapDmg then
sOut = sOut..string.format(SW_PRINT_ITEM, SW_PRINT_ITEM_DMG, caps[ reBI[3] ]).." ("..SW_PRINT_ITEM_IGNORED..")";
else
sOut = sOut..string.format(SW_PRINT_ITEM, SW_PRINT_ITEM_DMG, caps[ reBI[3] ]);
end
end
if reBI[4] then
if caps[ reBI[4] ] == nil then
caps[ reBI[4] ] = "??";
end
sOut = sOut..string.format(SW_PRINT_ITEM, SW_PRINT_ITEM_HEAL, caps[ reBI[4] ]);
end
if reBI[5] then
if caps[ reBI[5] ] == nil then
caps[ reBI[5] ] = "??";
end
sOut = sOut..string.format(SW_PRINT_ITEM, SW_PRINT_ITEM_THROUGH, caps[ reBI[5] ]);
end
if reBI[6] then
if caps[ reBI[6] ] == nil then
caps[ reBI[6] ] = "??";
end
sOut = sOut..string.format(SW_PRINT_ITEM, SW_PRINT_ITEM_TYPE, caps[ reBI[6] ]);
end
if isCrit then
sOut = sOut..SW_PRINT_ITEM_CRIT;
end
SW_Event_Channel:AddMessage(sOut);
end
end
--1.5.1 Decurse Counting
local function SW_CheckDecurse(event)
local re;
local reBI;
local from;
local to;
local what;
local spellID;
local r;
for _,v in ipairs(SW_EventRegexMap[SW_DECURSEDUMMY]) do
r = SW_getInfo(arg1, SW_RegEx_Lookup[v]);
if r~=nil then
re = SW_RegEx_Lookup[v];
reBI= re["basicInfo"];
from = reBI[1];
to = reBI[2];
what = reBI[5];
if what == nil then
what = SW_PRINT_ITEM_NORMAL;
else
what = r[what];
if what == nil then what = "??"; end
end
-- this isn't perfect "what" can still be a number of false captures
-- the lookup makes it safe though
spellID = SW_SpellIDLookUp[what];
if spellID ~= nil then
if from == nil then
from = SW_PRINT_ITEM_WORLD;
else
if from == -1 then from = SW_SELF_STRING; else from = r[from]; end
if from == nil then from = "??"; end
end
if to == nil then
to = SW_PRINT_ITEM_WORLD;
else
if to == -1 then to = SW_SELF_STRING; else to = r[to] end
if to == nil then to = "??"; end
end
if SW_S_SpellInfo[from] == nil then
SW_S_SpellInfo[from] = {};
end
if SW_S_SpellInfo[from][SW_DECURSEDUMMY] == nil then
SW_S_SpellInfo[from][SW_DECURSEDUMMY] = {};
end
if SW_S_SpellInfo[from][SW_DECURSEDUMMY]["total"] == nil then
SW_S_SpellInfo[from][SW_DECURSEDUMMY]["total"] = 1;
else
SW_S_SpellInfo[from][SW_DECURSEDUMMY]["total"] = SW_S_SpellInfo[from][SW_DECURSEDUMMY]["total"] + 1;
end
if SW_S_SpellInfo[from][SW_DECURSEDUMMY][what] == nil then
SW_S_SpellInfo[from][SW_DECURSEDUMMY][what] = 1;
else
SW_S_SpellInfo[from][SW_DECURSEDUMMY][what] = SW_S_SpellInfo[from][SW_DECURSEDUMMY][what] + 1;
end
--[[
if SW_DECEV[event] == nil then
SW_DECEV[event] = {};
end
table.insert(SW_DECEV[event], {from .. "; to '" .. to .. "'; " .. what, SW_RegEx_Lookup[v][r], arg1} );
--]]
return true;
end
end
end
return false;
end
local function findEventMatch(event)
-- only interested in stuff with numbers
-- V0.92 Changed this regex
--V 1.1.0 Added () -- fix for french crit vals
-- 1.4.2 made regex a var to be localized see neutral.lua
if not string.find (arg1, SW_PRE_REGEX) then
SW_CheckDecurse(event);
return false, "NUMBER";
end
--[[SW_TmpMap
if you change this change SW_CreateEventRegexMap
Its a map of regex to check first, point is if we find the
default map had erros we put these here first to enable transition
to a new default map, why here?.. becaue here we add messages that would be handeld by other regexp
if SW_TmpMap ~= nil then
for _,v in ipairs(SW_TmpMap) do
r = SW_getInfo(arg1, SW_RegEx_Lookup[v]);
if r~=nil then
SW_lateAdd(event, v, SW_EventRegexMap, SW_Map, true);
end
end
end
--]]
local r;
if SW_EventRegexMap[event] ~= nil then
for _,v in ipairs(SW_EventRegexMap[event]) do
r = SW_getInfo(arg1, SW_RegEx_Lookup[v]);
if r~=nil then
SW_handleMatch(event, v, r);
return true;
end
end
else
SW_printStr(RED_FONT_COLOR_CODE..SW_EMPTY_EVENT..event, 1);
end
local r;
-- if we get here see if it was env dmg
if SW_EventRegexMapEnviro[event] ~= nil then
for _,v in ipairs(SW_EventRegexMapEnviro[event]) do
r = SW_getInfo(arg1, SW_RegEx_Lookup[v]);
if r~=nil then
SW_handleMatch(event, v, r);
return true;
end
end
end
return false, "NF";
end
local function doFallback(event)
-- we didn't find a regex that fits
-- the SW_DEV_EVENTDUMMY has all defined that we are "listening" to
local r;
for _,v in ipairs(SW_EventRegexMap[SW_DEV_EVENTDUMMY]) do
r = SW_getInfo(arg1, SW_RegEx_Lookup[v]);
if r~=nil then
if string.sub(v,1,string.len("VSENVIRONMENTALDAMAGE"))=="VSENVIRONMENTALDAMAGE" then
SW_lateAdd(event, v, SW_EventRegexMapEnviro, SW_EnviroMap);
else
SW_lateAdd(event, v, SW_EventRegexMap, SW_Map);
end
SW_handleMatch(event, v, r);
return true;
end
end
return false;
end
function SW_DoEvent(event)
if arg1 == nil then
SW_printStr("arg1 NIL For:"..event);
return;
end
local isOk, reason = findEventMatch(event);
if not isOk and reason == "NF" then
SW_printStr(RED_FONT_COLOR_CODE..event, 2);
SW_printStr(RED_FONT_COLOR_CODE.." "..arg1, 2);
if SW_Fallback_Block[event] == nil then
if doFallback(event) then
SW_printStr(GREEN_FONT_COLOR_CODE.." "..SW_CONSOLE_FALLBACK, 2);
else
SW_printStr(RED_FONT_COLOR_CODE.." "..SW_CONSOLE_NOREGEX, 2);
SW_Fallback_Block[event] = arg1;
end
else
SW_printStr(RED_FONT_COLOR_CODE.." "..SW_FALLBACK_BLOCK_INFO, 2);
SW_printStr(RED_FONT_COLOR_CODE.." "..SW_CONSOLE_NOREGEX, 2);
SW_printStr(RED_FONT_COLOR_CODE.." "..SW_Fallback_Block[event], 2);
end
end
end
function SW_Test(subMap)
if subMap == nil then
for k,v in pairs(SW_EventRegexMap) do
SW_printStr (k);
for _,x in ipairs(v) do
SW_printStr(" "..x.." ---- "..SW_RegEx_Lookup[x]["r"]);
end
end
else
SW_printStr (subMap);
for _,x in ipairs(SW_EventRegexMap[subMap]) do
SW_printStr(" "..x.." ---- "..SW_RegEx_Lookup[x]["r"]);
end
end
end
-- 1.5 new pet mechanics
function SW_PetHasOwner(petName)
local petInfo = SW_PetInfo["PET_OWNER"][petName];
if petInfo ~= nil and petInfo["currentOwners"] ~= nil then
for k, v in pairs(petInfo["currentOwners"]) do
return true;
end
end
return false;
end
-- resets current petownership to nothing
function SW_PetsResetOwners()
for k, v in pairs(SW_PetInfo["OWNER_PET"]) do
v["currentPet"] = nil;
end
for k, v in pairs(SW_PetInfo["PET_OWNER"]) do
v["currentOwners"] = {};
end
end
function SW_HandlePetEvent(petName, petsAction, dmg, heal)
local petInfo = SW_PetInfo["PET_OWNER"][petName];
local tmpInfo = nil;
local oneOwner = nil;
local hadOwner = false;
if petInfo == nil then return; end
if petInfo["currentOwners"] == nil then return; end
for k, v in pairs(petInfo["currentOwners"]) do
hadOwner = true;
oneOwner = SW_PetInfo["OWNER_PET"][k];
if oneOwner ~= nil then
if oneOwner["currentPet"] == petName then -- through setup should always be true
if petsAction then
tmpInfo = oneOwner["pets"][petName][SW_PRINT_ITEM_TOTAL_DONE];
else
tmpInfo = oneOwner["pets"][petName][SW_PRINT_ITEM_RECIEVED];
end
tmpInfo[1] = tmpInfo[1] + dmg;
tmpInfo[2] = tmpInfo[2] + heal;
if petsAction then
tmpInfo = oneOwner[SW_PRINT_ITEM_TOTAL_DONE];
else
tmpInfo = oneOwner[SW_PRINT_ITEM_RECIEVED];
end
tmpInfo[1] = tmpInfo[1] + dmg;
tmpInfo[2] = tmpInfo[2] + heal;
end
end
end
if hadOwner then
if petsAction then
tmpInfo = petInfo[SW_PRINT_ITEM_TOTAL_DONE];
else
tmpInfo = petInfo[SW_PRINT_ITEM_RECIEVED];
end
tmpInfo[1] = tmpInfo[1] + dmg;
tmpInfo[2] = tmpInfo[2] + heal;
end
end
function SW_UpdatePet(ownerID)
local ownerName = UnitName(ownerID);
local unitPetName = nil;
local unitPetID = nil;
local localizedClass, englishClass;
if ownerName == nil then return; end
-- translate target to raid/ group id
-- cant seem to get the pet of a "target" id
if ownerID == "target" then
if SW_Friends[ownerName] ~= nil then
-- should always be true just an extra check
if UnitIsUnit(SW_Friends[ownerName]["UnitID"], "target") then
ownerID = SW_Friends[ownerName]["UnitID"];
else
ownerID = nil;
end
else
ownerID = nil;
end
end
if (ownerID == nil) then return; end
-- here we have an id we can really use
if ownerID == "player" then
unitPetID = "pet";
elseif string.find(ownerID, "party") then
unitPetID = string.gsub(ownerID, "party", "partypet");
elseif string.find(ownerID, "raid") then
unitPetID = string.gsub(ownerID, "raid", "raidpet");
else
SW_printStr("SW_UpdatePet error ownerID is:"..ownerID);
return;
end
unitPetName = UnitName(unitPetID);
-- this tends to happen when logging in
-- once inside the game zoning and reloadui shouldn't trigger this
if unitPetName == UNKNOWNOBJECT then
--SW_printStr("Started UNKNOWNOBJECT timer");
SW_Timed_Calls.retryUnknownObject = true;
return;
end
-- no pet
if unitPetName == nil then
-- remove the owner
for k,v in pairs(SW_PetInfo["PET_OWNER"]) do
if v["currentOwners"] ~= nil then
v["currentOwners"][ownerName] = nil;
end
end
if SW_PetInfo["OWNER_PET"][ownerName] ~= nil then
SW_PetInfo["OWNER_PET"][ownerName]["currentPet"] = nil;
end
end
if unitPetName ~= nil and unitPetName ~= UNKNOWNOBJECT then
-- setup pet owner
if SW_PetInfo["PET_OWNER"][unitPetName] == nil then
SW_PetInfo["PET_OWNER"][unitPetName] = {};
SW_PetInfo["PET_OWNER"][unitPetName][SW_PRINT_ITEM_TOTAL_DONE] = {0,0};
SW_PetInfo["PET_OWNER"][unitPetName][SW_PRINT_ITEM_RECIEVED] = {0,0};
SW_PetInfo["PET_OWNER"][unitPetName]["currentOwners"] = {};
SW_PetInfo["PET_OWNER"][unitPetName]["currentOwners"][ownerName] = true;
localizedClass, englishClass = UnitClass(unitPetID);
if englishClass ~= nil and localizedClass ~= nil then
SW_ClassNames[englishClass] = localizedClass;
end
-- englishClass might be nill but thats fine
SW_PetInfo["PET_OWNER"][unitPetName]["CLASSE"] = englishClass;
else
-- need this check because of sync channel
if SW_PetInfo["PET_OWNER"][unitPetName]["currentOwners"] == nil then
SW_PetInfo["PET_OWNER"][unitPetName]["currentOwners"] = {};
end
SW_PetInfo["PET_OWNER"][unitPetName]["currentOwners"][ownerName] = true;
-- sometimes class info doesn't carry over (pet is to far away)
-- so recheck it
if SW_PetInfo["PET_OWNER"][unitPetName]["CLASSE"] == nil then
localizedClass, englishClass = UnitClass(unitPetID);
if englishClass ~= nil and localizedClass ~= nil then
SW_ClassNames[englishClass] = localizedClass;
end
SW_PetInfo["PET_OWNER"][unitPetName]["CLASSE"] = englishClass;
end
end
-- setup owner pet
if SW_PetInfo["OWNER_PET"][ownerName] == nil then
SW_PetInfo["OWNER_PET"][ownerName] = {};
SW_PetInfo["OWNER_PET"][ownerName]["pets"] = {};
SW_PetInfo["OWNER_PET"][ownerName][SW_PRINT_ITEM_TOTAL_DONE] = {0,0};
SW_PetInfo["OWNER_PET"][ownerName][SW_PRINT_ITEM_RECIEVED] = {0,0};
end
-- very odd had a report so added this, why would this be needed?
-- ah ok if its inited through the sync channel this is needed.
if SW_PetInfo["OWNER_PET"][ownerName]["pets"] == nil then
SW_PetInfo["OWNER_PET"][ownerName]["pets"] = {};
end
if SW_PetInfo["OWNER_PET"][ownerName]["pets"][unitPetName] == nil then
SW_PetInfo["OWNER_PET"][ownerName]["pets"][unitPetName] = {};
SW_PetInfo["OWNER_PET"][ownerName]["pets"][unitPetName][SW_PRINT_ITEM_TOTAL_DONE] = {0,0};
SW_PetInfo["OWNER_PET"][ownerName]["pets"][unitPetName][SW_PRINT_ITEM_RECIEVED] = {0,0};
end
SW_PetInfo["OWNER_PET"][ownerName]["currentPet"] = unitPetName;
--SW_Pets[unitPetName] = ownerName;
if SW_Friends[ownerName] == nil then
SW_Friends[ownerName] = {};
SW_Friends[ownerName]["PETS"] = {};
elseif SW_Friends[ownerName]["PETS"] == nil then
SW_Friends[ownerName]["PETS"] = {};
end
SW_Friends[ownerName]["PETS"][unitPetName] = 1;
end
end
-- creats the "friends" list
-- self, group members, or raid members
function SW_Make_Friends(gType)
local name, rank,sg,lev;
local namePet;
local playerClass, englishClass = UnitClass("player");
SW_ClassNames[englishClass] = playerClass;
SW_Friends = {[SW_SELF_STRING]=
{["CLASS"] = playerClass, ["CLASSE"] = englishClass, ["UnitID"]="player", ["L"] = UnitLevel("player")},
};
--1.4.2 add rank info when we are alone will be overwritten if in raid/group
SW_Friends[SW_SELF_STRING]["Rank"] = 0;
--update pet info
SW_PetsResetOwners();
SW_UpdatePet("player");
--[[
1.4.2 Changed to GetRaidRosterInfo need rank info now
probably could use class and fileName instead of UnitClass(...)
--]]
if gType == "RAID" then
for i=1, GetNumRaidMembers() do
--name =UnitName("raid"..i);
--name, rank, subgroup, level, class, fileName, zone, online, isDead = GetRaidRosterInfo(i)
name, rank,sg,lev = GetRaidRosterInfo(i);
if name ~= nil then
playerClass, englishClass = UnitClass("raid"..i);
if englishClass ~= nil and playerClass ~= nil then
SW_ClassNames[englishClass] = playerClass;
SW_Friends[name] = {["CLASS"] = playerClass, ["CLASSE"] = englishClass, ["UnitID"]="raid"..i, ["Rank"]=rank, ["L"] = lev };
end
SW_UpdatePet("raid"..i);
end
end
return;
end
if gType == "GROUP" then
for i=1, GetNumPartyMembers() do
name =UnitName("party"..i);
if name ~= nil then
playerClass, englishClass = UnitClass("party"..i);
if UnitIsPartyLeader("party"..i) then
rank = 2;
else
rank = 0;
end
if englishClass ~= nil and playerClass ~= nil then
SW_ClassNames[englishClass] = playerClass;
SW_Friends[name] = {["CLASS"] = playerClass, ["CLASSE"] = englishClass, ["UnitID"]="party"..i, ["Rank"]=rank, ["L"] = UnitLevel("party"..i)};
end
SW_UpdatePet("party"..i);
end
end
--1.4.2 check self as party leader
if IsPartyLeader() then
SW_Friends[SW_SELF_STRING]["Rank"] = 2;
end
return;
end
end
--[[
SW_TestState = {
_memberVar,
Test = function (self, test)
self._memberVar = test;
x=0;
for i=1, 1000000 do
x=x+1;
end
if self._memberVar == test then
SW_printStr(test.." OK");
else
SW_printStr(test.." FAILED");
end
end,
}
--]]
SW_Timed_Calls = {
deltaPending = 0.5, -- 1.4 beta 5 increased + 0.1
passedPendig =0,
pendingActive = false,
deltaResize = 0.5,
passedResize = 0,
deltaSySend = 1.1, -- + 0.1 in 1.2.4 a few more checks going on
passedSySend = 0,
deltaSyDo = 5,
passedSyDo = 0,
deltaSyLI = 100, -- lowerd to 100
passedSyLI = 0,
retryUnknownObject = false, -- added in 1.5 pet mechanics using SyDo timer
pendingJoin = false, -- added in 1.5 for sync joining, using SySend timer
checkJoin = false, -- added in 1.5 for checking if we REALLY are in the chan, using SySend timer
OnUpdate = function (self, elapsed)
self.passedResize = self.passedResize + elapsed;
self.passedSySend = self.passedSySend + elapsed;
self.passedSyDo = self.passedSyDo + elapsed;
self.passedSyLI = self.passedSyLI + elapsed;
if (SW_CombatTimeInfo.awaitingEnd) then
SW_CombatTime = SW_CombatTime + elapsed;
end
if self.pendingActive then
self.passedPendig = self.passedPendig + elapsed;
if self.passedPendig > self.deltaPending then
self.pendingActive = false;
self.passedPendig = 0;
SW_AcceptPendingCast();
end
end
if self.passedResize > self.deltaResize then
if SW_SomethingResizing then
SW_BarLayoutRegisterdOnResize();
end
self.passedResize = 0;
end
if self.passedSySend > self.deltaSySend then
-- added 1.5.3 for raid per second info
SW_RPS:updateInfo();
-- added in 1.5 joining a chan is now on a short timer
-- to allow exit of old sync chan first
if self.checkJoin then
self.checkJoin = false;
SW_SyncJoinedCheck();
end
if self.pendingJoin then
self.pendingJoin = false;
SW_SyncJoinPending();
end
SW_SyncSend();
-- added 1.5.beta.1 for voting system
SW_UpdateVoteTimers(self.deltaSySend);
if not SW_SomethingResizing then
SW_UpdateBars();
end
self.passedSySend = 0;
end
if self.passedSyDo > self.deltaSyDo then
-- added in 1.5 this should only happen when logging in
if self.retryUnknownObject then
self.retryUnknownObject = false;
--SW_printStr("UNKNOWNOBJECT timer fired");
SW_RebuildFriendList();
end
SW_SyncDo();
self.passedSyDo = 0;
end
if self.passedSyLI > self.deltaSyLI then
SW_SyncCheckAlive();
self.passedSyLI = 0;
end
end,
StopPending = function (self)
self.pendingActive = false;
self.passedPendig = 0;
end,
StartPending = function (self)
self.pendingActive = true;
end,
StartJoinChanPending = function (self)
self.passedSySend = 0;
self.pendingJoin = true;
end,
StopJoinChanPending = function (self)
self.pendingJoin = false;
end,
StartCheckChan = function (self)
self.passedSySend = 0;
self.checkJoin = true;
end,
StopCheckChan = function (self)
self.checkJoin = false;
end,
};
-- this doesnt work like intended, eg talking to nef starts this oO
--[[
function SW_RaidInfightUpdate()
local indi = getglobal("SW_BarFrame1_Title_InFight");
for k,v in pairs(SW_Friends) do
if v["UnitID"] ~= nil then
if UnitAffectingCombat(v["UnitID"]) then
indi.NormalT:SetVertexColor(0,1,0,1);
return;
end
end
end
indi.NormalT:SetVertexColor(1,0,0,1);
end
--]]
function SW_AddDeath(name)
if name == nil then return; end
if SW_S_Details[name] == nil then
SW_S_Details[name] = {};
SW_S_Details[name][SW_PRINT_ITEM_TOTAL_DONE] = {0,0};
SW_S_Details[name][SW_PRINT_ITEM_RECIEVED] = {0,0};
SW_S_Details[name][SW_PRINT_ITEM_TYPE] = {};
end
if SW_S_Details[name][SW_PRINT_ITEM_DEATHS] == nil then
SW_S_Details[name][SW_PRINT_ITEM_DEATHS] = 1;
else
SW_S_Details[name][SW_PRINT_ITEM_DEATHS] = SW_S_Details[name][SW_PRINT_ITEM_DEATHS] + 1;
end
end
function SW_HandleDeath(msg)
if msg == nil then return; end
if msg == UNITDIESSELF then
SW_AddDeath(SW_SELF_STRING);
else
local _,_, deadGuy = string.find(msg, SW_DeathRegEx);
SW_AddDeath(deadGuy);
end
end
--[[
Note to self, add HPS aswell
--]]
SW_C_RPS ={
filters = {["SF"] = "SW_Filter_EverGroup", ["PF"] = "SW_PF_VPR"},
new = function (self, o)
local doResetInit = true;
if o then
doResetInit = false;
else
o = {};
end
setmetatable(o, self);
self.__index = self;
o.baseTimer = SW_C_Timer:new(o.baseTimer);
o.startTimer = SW_C_Timer:new(o.startTimer);
if doResetInit then
o:resetDPS();
end
return o;
end,
resetDPS = function(self)
self.isRunning = false;
self.allowLastFightUpdate = false;
self.currentSecs = 0;
self.totalSecs = 0;
self.lastFightSecs = 0;
self.startDmg = 0;
self.maxDPS = 0;
self.lastFightDmg = 0;
self.uglyTruthStarted = false;
self.resetPoint = self:getDmg();
SW_BarFrame1_Title_SyncIcon:UpdateColor(SW_Settings["Colors"]["Heal"]);
end,
validEvent = function (self)
self.lastEvent = self.baseTimer:now();
-- even with the ugly truth time be so nice to wait for first dmg
if not self.uglyTruthStarted then
self.uglyTruthStarted = true;
self.baseTimer:setToNow();
end
if not self.isRunning then
self.startTimer:setToNow();
self.allowLastFightUpdate = false;
self.startDmg = self:getDmg();
self.isRunning = true;
SW_BarFrame1_Title_SyncIcon:UpdateColor(SW_Settings["Colors"]["Damage"]);
end
end,
updateInfo = function (self)
if not self.isRunning then return; end
local deltaT = self.startTimer:now() - self.lastEvent;
if deltaT > 6 then -- a buffer to keep you "in fight" 1.5.3.beta.1 changed from 5 to 6 (late sync msgs)
self.isRunning = false;
self.currentSecs = 0;
deltaT = self.lastEvent - self.startTimer;
if deltaT < 1 then deltaT = 1; end -- 1 sec minimum fight time
self.totalSecs = self.totalSecs + deltaT;
self.lastFightSecs = deltaT;
self.allowLastFightUpdate = true;
SW_BarFrame1_Title_SyncIcon:UpdateColor(SW_Settings["Colors"]["Heal"]);
else
self.currentSecs = self.startTimer:elapsed();
SW_BarFrame1_Title_SyncIcon:UpdateColor(SW_Settings["Colors"]["Damage"]);
end
end,
getDmg = function(self)
local snap = SW_GetDmgInfo("SW_Filter_EverGroup", nil, "SW_PF_VPR", self.filters);
local total = 0;
for i,v in ipairs(snap) do
total = total + v[2];
end
return total;
end,
getVals = function (self)
local ret = {};
local currDmg = self:getDmg();
local currDelta = currDmg - self.startDmg;
if self.currentSecs == 0 then
ret[1] = 0;
else
if self.currentSecs < 1 then
ret[1] = math.floor(currDelta *100 + 0.5)/100;
else
ret[1] = math.floor((currDelta / self.currentSecs) *100 + 0.5)/100;
end
end
if self.totalSecs == 0 and self.currentSecs == 0 then
ret[2] = 0;
else
--SW_printStr((currDmg - self.resetPoint)..".."..(self.totalSecs + self.currentSecs));
ret[2] = math.floor(((currDmg - self.resetPoint) / (self.totalSecs + self.currentSecs)) *100 + 0.5)/100;
end
if self.lastFightSecs == 0 then
ret[3] = 0;
else
if self.allowLastFightUpdate then
-- only point of this is to accept late sync messages
-- in testing this made (almost) no difference
self.lastFightDmg = currDelta;
end
ret[3] = math.floor((self.lastFightDmg / self.lastFightSecs) *100 + 0.5)/100;
end
if self.uglyTruthStarted then
ret[4] = math.floor(((currDmg - self.resetPoint) / self.baseTimer:elapsed()) *100 + 0.5)/100;
end
if not self.isRunning or self.currentSecs > 5 then
for i,v in ipairs(ret) do
if v > self.maxDPS then
self.maxDPS = v;
end
end
end
return ret;
end,
dump = function (self)
SW_DumpTable(self);
end,
}
function SW_Stats_OnEvent()
if (event == "VARIABLES_LOADED") then
-- init code will go here considering saved vars
-- 1.5 Current pet ownership reset, will be updated through other events on login
SW_PetsResetOwners();
-- 1.5.1 decurseing, could be used for more
SW_CreateSpellIDLookup();
-- 1.5 added pausing, default to running for old versions and new installs
if SW_Settings["IsRunning"] == nil then
SW_Settings["IsRunning"] = true;
end
if SW_Settings["IsRunning"] then
SW_UnpauseEvents();
end
if SW_Map == nil then
SW_Map = SW_DefaultMap;
else
if SW_Settings["LAST_V_RUN"] == nil then
SW_Map = SW_DefaultMap;
SW_Fallback_Block = {};
else
if SW_Settings["LAST_V_RUN"] ~= SW_VERSION then
SW_Map = SW_DefaultMap;
SW_Fallback_Block = {};
SW_ResetInfo();
end
end
end
SW_DefaultMap = nil;
if SW_EnviroMap == nil then
SW_EnviroMap ={};
end
SW_CreateEventRegexMap();
SW_SL_Finalize();
SW_SELF_STRING = UnitName("player");
if SW_Settings["SyncBCTarget"] == nil then
SW_Settings["SyncBCTarget"] = "SW_BarSyncFrame_OptRaid";
end
-- sets the checkboxes to saved values
SW_SetChkStates();
SW_Event_Channel = getglobal("SW_FrameConsole_Text2_MsgFrame");
SW_EI_ALLOFF = not (SW_Settings["EI_ShowRegEx"] or SW_Settings["EI_ShowMatch"]
or SW_Settings["EI_ShowEvent"] or SW_Settings["EI_ShowOrigStr"]);
SW_Settings["LAST_V_RUN"] = SW_VERSION;
if SW_Settings["QuickOptCount"] == nil then
SW_Settings["QuickOptCount"] = 5;
end
SW_UpdateOptVis();
-- wow what a headache, an addon called sweep overwrites this with a number oO
-- causing all sorts of problems
-- it's not great just to skip it but we can get along without seeding the generator
if type(math.randomseed) == "function" then
math.randomseed( time() );
else
SW_printStr("math.randomseed is not a funtion... it should be");
end
-- localize gui
for k,v in pairs(SW_GUI) do
--if its not a table the key is a direct map to the string
if type(v) ~= "table" then
getglobal(k):SetText(v);
else
--[[v["f"] is the function
k is the identifier for the function
v["s"] is the string
]]--
v["f"](k,v["s"]);
end
end
-- done localizing gui.. drop table
SW_GUI = nil;
-- do layout of items
SW_DoLayout();
SW_SyncInit();
if SW_Settings["ReportAmount"] == nil then
SW_Settings["ReportAmount"] = 5;
end
if SW_Settings["Colors"] == nil then
SW_Settings["Colors"] = {};
end
for k,v in pairs(SW_Default_Colors) do
if SW_Settings["Colors"][k] == nil then
SW_Settings["Colors"][k] = v;
end
end
if ButtonHole then
ButtonHole.application.RegisterMod({id="SW_STATS_BH_HOOK",
name="SW Stats",
tooltip="SW Stats",
buttonFrame="SW_IconFrame",
updateFunction="SW_UpdateIconPos"});
else
SW_UpdateIconPos();
end
--1.5.3 default color mechaniks changed
if SW_Settings["Colors"]["TitleBars"] == nil then
SW_Settings["Colors"]["TitleBars"] = {1,0,0,1};
end
SW_UpdateTitleColor(SW_Settings["Colors"]["TitleBars"]);
if SW_Settings["Colors"]["TitleBarsFont"] == nil then
SW_Settings["Colors"]["TitleBarsFont"] = {1,1,1,1};
end
SW_UpdateTitleTextColor(SW_Settings["Colors"]["TitleBarsFont"]);
if SW_Settings["Colors"]["Backdrops"] == nil then
SW_Settings["Colors"]["Backdrops"] = {SW_COLOR_ACT["r"],SW_COLOR_ACT["g"],SW_COLOR_ACT["b"],1};
end
SW_UpdateFrameBackdrops(SW_Settings["Colors"]["Backdrops"]);
if SW_Settings["Colors"]["MainWinBack"] == nil then
SW_Settings["Colors"]["MainWinBack"] = {0,0,0,0.6};
end
SW_UpdateMainWinBack(SW_Settings["Colors"]["MainWinBack"])
-- 1.5.3 Sync Icon
if SW_Settings["SYNCLastChan"] ~= nil then
SW_BarFrame1_Title_SyncIcon:Show();
SW_BarFrame1_Title_SyncIcon:UpdateColor(SW_Settings["Colors"]["Heal"]);
end
--1.5.3 retaining vis of the main window
if SW_Settings["SHOWMAIN"] then
SW_BarFrame1:Show();
end
-- 1.5.3.beta.1 locking frames
SW_LockFrames(SW_Settings["BFLocked"]);
-- 1.5.3 Raid dps info
SW_RPS = SW_C_RPS:new(SW_RPS);
--SW_ToggleConsole();
elseif (event == "PLAYER_TARGET_CHANGED") then
local unitName = UnitName("target");
if unitName == nil then return; end
local localizedClass, englishClass = UnitClass("target");
--1.0.2 added this, could happen with far away pets
if localizedClass == nil or englishClass == nil then return; end
SW_ClassNames[englishClass] = localizedClass;
-- ignore if we dont have info
if SW_S_Details[unitName] == nil then return; end
SW_S_Details[unitName]["CLASSE"] = englishClass;
--1.5 added GPC and GPET
if UnitPlayerControlled("target") then
if SW_Friends[unitName] ~= nil then
SW_S_Details[unitName]["UTYPE"] = "GPC";
elseif SW_PetInfo["PET_OWNER"][from] ~= nil then
-- don't mark MC'd mobs as gpet
if SW_S_Details[unitName]["UTYPE"] ~= "NPC" then
SW_S_Details[unitName]["UTYPE"] = "GPET";
end
else
SW_S_Details[unitName]["UTYPE"] = "PC";
end
else
SW_S_Details[unitName]["UTYPE"] = "NPC";
end
--[[
if UnitIsEnemy("player", "target") then
SW_printStr("ENEMY");
else
SW_printStr("Friend");
end
--]]
elseif (event == "SPELLS_CHANGED") then
-- update if we learn new spells
if arg1 == nil then
SW_UpdateCastByNameLookup();
end
elseif (event == "SPELLCAST_CHANNEL_START") then
--SW_printStr("-CHANNELSTART-");
SW_AcceptSelectedCast();
--[[elseif (event == "SPELLCAST_START") then
SW_printStr("-START-"); ]]--
elseif (event == "SPELLCAST_STOP") then
--SW_printStr("-SPELLCAST_STOP- :");
--SW_printStr(SW_SelectedSpell[1]);
if SW_SelectedSpell[1] ~= nil then
--SW_printStr("-SPELLCAST_STOP:"..SW_SelectedSpell[1]);
-- is this an instant ?
if SW_SelectedSpell[3] then
SW_AcceptSelectedCast();
else
SW_PendingCast[1] = SW_SelectedSpell[1];
SW_PendingCast[2] = SW_SelectedSpell[2];
SW_SelectedSpell = {};
--SW_printStr("-STOP NP-"..SW_PendingCast[1]);
SW_Timed_Calls:StartPending();
end
end
elseif event == "SPELLCAST_FAILED" or event == "SPELLCAST_INTERRUPTED" then
--SW_printStr("-SPELLCAST_FAIL-");
SW_Timed_Calls:StopPending();
SW_SelectedSpell = {};
SW_PendingCast = {};
elseif (event == "CHAT_MSG_GUILD") then
SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "CHAT_MSG_OFFICER") then
SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "CHAT_MSG_PARTY") then
SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "CHAT_MSG_RAID") then
SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "CHAT_MSG_RAID_LEADER") then
SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "CHAT_MSG_CHANNEL") then
if arg8 == SW_SyncChanID then
SW_SyncHandleMsg(arg1, arg2);
end
--elseif (event == "CHAT_MSG_SAY") then
-- SW_SyncCheckMsgForChan(arg1,arg2);
elseif (event == "PLAYER_ENTERING_WORLD") then
--bar layout needs to go here, only then the "saved (layout-cache.txt)" layout is loaded already
SW_BarLayoutRegisterd();
if GetNumRaidMembers() > 0 then
SW_Make_Friends("RAID");
elseif GetNumPartyMembers() > 0 then
SW_Make_Friends("GROUP");
else
SW_Make_Friends();
end
SW_UpdateCastByNameLookup();
elseif (event == "UNIT_PET") then
--SW_printStr("UNIT_PET "..arg1);
SW_UpdatePet(arg1);
elseif (event == "PARTY_MEMBERS_CHANGED") or (event == "PARTY_LEADER_CHANGED") then
--SW_printStr("PARTY_MEMBERS_CHANGED ");
if UnitInRaid("player") then
return;
end
SW_Make_Friends("GROUP");
elseif (event == "RAID_ROSTER_UPDATE") then
SW_Make_Friends("RAID");
local sf = getglobal("SW_BarSyncFrame");
if sf:IsVisible() then
sf:UpdateARPVis();
end
elseif (event == "CHAT_MSG_COMBAT_FRIENDLY_DEATH") then
SW_HandleDeath(arg1);
elseif (event == "CHAT_MSG_COMBAT_HOSTILE_DEATH") then
SW_HandleDeath(arg1);
elseif (event == "PLAYER_REGEN_DISABLED") then
SW_CombatTimeInfo.awaitingStart = true;
elseif (event == "PLAYER_REGEN_ENABLED") then
SW_CombatTimeInfo.awaitingStart = false;
SW_CombatTimeInfo.awaitingEnd = false;
else
SW_DoEvent(event);
end
end
if not SW_DEV_INWOW then
SW_SL_Add(SW_SL["START"]);
SW_CreateRegexFromGlobals();
SW_CreateEventRegexMap();
SW_SL_Finalize();
SW_Test();
end
Generated by GNU Enscript 1.6.5.90.