Files
DmorphOcto/Share.lua
T
bdot89andClaude Opus 5.5 b475d865d1 DMorph 1.8.0: quiet morph sharing
- Group, raid, battleground and guild mates get hidden addon messages;
  only players outside those hear the channel, now "DmorphShare" (with a
  password). Every channel message and notice is filtered out of the chat
  windows, and 1.7's "DmorphOcto" channel is left.
- Changes go out once they stand still for 1 s (at most 3 s late), as one
  message, and only to DMorph users around you or who asked about you.
- Mounting and dismounting is a tiny "M" message that always goes first.
- Looks are base 36 and remembered per realm for two weeks: known players
  show at once and are asked with a fingerprint, answered by a fingerprint
  when nothing changed. Duplicate channel questions are dropped.
- Outgoing messages are paced (0.6 s channel, 0.2 s hidden); .share shows
  how many went out. New protocol DMO2: 1.7 and 1.8 don't see each other.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LYRNpwDuww8EG5hoZQYyo6
2026-10-10 23:57:20 +00:00

931 lines
27 KiB
Lua

-- DMorph for OctoWoW: other DMorph users see your morph, and you see theirs.
--
-- Each client tells the others what it looks like (body, item morphs, and
-- the mount skin while it rides). Each client then morphs those players on
-- its own screen through VanillaHelpers whenever it has a unit token for
-- them: target, mouseover, target of target, party, raid, or with SuperWoW
-- their GUID. VanillaHelpers only morphs friendly players. Nobody without
-- DMorph sees anything different.
--
-- Talking as little as possible (the server slows down anyone who chats fast):
-- * Group, raid, battleground and guild mates get hidden addon messages.
-- Only players outside those hear us on DMorph's own chat channel, which
-- no chat window shows.
-- * Your changes go out once they stand still for a second (one message for
-- a whole outfit), and only to the players who are around you and have
-- DMorph. Anyone else asks when they see you.
-- * Mounting and dismounting is a tiny message of its own that goes first.
-- * Looks are short (base 36) and remembered between sessions. A question
-- carries a fingerprint of the look we remember, and the answer is a
-- fingerprint too when nothing changed.
--
-- VanillaHelpers keeps a morph on the player's GUID, but when a player leaves
-- your sight and comes back the game builds them afresh without it. So every
-- fifth of a second the addon looks at the players it knows and puts the look
-- straight back on anyone who has just come back into view.
--
-- Messages (prefix "DMO2"). A look is "<display> <mount> <items>": display and
-- mount IDs in base 36 (0 = none), items as a slot letter (a = 1 ... s = 19)
-- and an item ID in base 36 each, or "-".
-- L <look> <guid|-> this is my look
-- M <mount> my mount skin changed, the rest didn't
-- H <fingerprint> <guid|-> my look is still the one with this fingerprint
-- Q <name>[:<fingerprint>],... what do these players look like now?
-- Questions are answered on the way they came (channel, group or guild).
local M = DmorphOcto
local CHANNEL, PASSWORD = "DmorphShare", "dmo2"
local OLD_CHANNEL = "DmorphOcto" -- 1.7's channel: left after login
local TAG = "DMO2"
local TICK, SCAN_GAP = 0.1, 0.2
local SETTLE, MAX_WAIT = 1, 3 -- send a changed look once it stands still this long, at most this late
local CHANNEL_GAP, ADDON_GAP = 0.6, 0.2 -- between our messages
local JOIN_DELAY, READY_DELAY = 3, 2 -- after login: join the channel, then talk
local REPLY_GAP = 3 -- answer questions about us at most this often (per way)
local QUERY_GAP = 3 -- ask about players at most this often
local ASK_AGAIN = 300 -- ask a player without DMorph again after this long
local RECHECK = 60 -- ask a DMorph user who comes back into sight whether they changed, at most this often
local CONFIRM_WAIT = 20 -- a remembered player who doesn't answer in this long has no DMorph now
local AUDIENCE = 180 -- DMorph users seen this recently, or who asked about us, get our changes
local GUILD_GAP = 120 -- refresh the guild list this often
local KEEP = 14 * 86400 -- forget remembered looks after two weeks
local MAX_ASK = 12
local MAX_PEERS = 500
local clock, scanID = 0, 0
local peers, peerCount = {}, 0 -- name -> { display, mount, items, d, m, it, look, print, guid, version, heard, confirmed }
local applied = {} -- name -> what we put on them: { display, mount, items, version, scan, away }
local asked, queue, queued = {}, {}, {} -- name -> when we last asked; names to ask about; name -> fingerprint or true
local audience = {} -- name -> when they last showed they see us
local inGroup, inGuild = {}, {} -- names
local replies = {} -- way -> "L" (full look) or "H" (fingerprint)
local timers = {} -- clock times: join, ready, send, first, mount, reply, replied, query, scan, guild, next
local sent = { d = "0", m = "0", it = "-" } -- what the others were last told
local cache -- DmorphOctoAccount.peerCache for this realm
local guidWorks -- whether VanillaHelpers took a GUID as a unit token (nil: not tried)
local counts = { channel = 0, hidden = 0 }
local function Sharing()
return not M.GetAccount().shareOff
end
local function Seeing()
return not M.GetAccount().othersOff
end
-- Short numbers --------------------------------------------------------------------
local DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
local function Encode(n)
n = math.floor(tonumber(n) or 0)
if n <= 0 then
return "0"
end
local text = ""
while n > 0 do
local digit = math.mod(n, 36)
text = strsub(DIGITS, digit + 1, digit + 1) .. text
n = math.floor(n / 36)
end
return text
end
local function Decode(text)
if text and strfind(text, "^[0-9A-Z]+$") and strlen(text) <= 6 then
return tonumber(text, 36)
end
end
-- A four-character fingerprint of a look.
local function Fingerprint(look)
local h = 5381
for i = 1, strlen(look) do
h = math.mod(h * 33 + string.byte(look, i), 1679609)
end
return Encode(h)
end
-- Our look's three parts, as the others should see it.
local function OwnParts()
if not Sharing() then
return "0", "0", "-"
end
local display, items, mount = M.GetSharedLook()
local parts = {}
for slot = 1, 19 do
if items[slot] then
table.insert(parts, string.char(96 + slot) .. Encode(items[slot]))
end
end
local itemText = "-"
if table.getn(parts) > 0 then
itemText = table.concat(parts)
end
return Encode(display), Encode(mount), itemText
end
local function OwnLook()
local d, m, it = OwnParts()
return d .. " " .. m .. " " .. it
end
-- SuperWoW's UnitExists also returns the unit's GUID.
local function GUIDOf(unit)
local ok, _, guid = pcall(UnitExists, unit)
if ok and type(guid) == "string" and strfind(guid, "^0x%x+$") then
return guid
end
end
-- Ways to reach players ------------------------------------------------------------
local function GroupChannel()
for i = 1, (MAX_BATTLEFIELD_QUEUES or 3) do
local ok, status = pcall(GetBattlefieldStatus, i)
if ok and status == "active" then
return "BATTLEGROUND"
end
end
if GetNumRaidMembers() > 0 then
return "RAID"
elseif GetNumPartyMembers() > 0 then
return "PARTY"
end
end
-- The quietest way to reach a player: their group or guild, or the channel.
local function Way(name)
local group = GroupChannel()
if group == "BATTLEGROUND" or (group and inGroup[name]) then
return group
elseif inGuild[name] then
return "GUILD"
end
return "CHANNEL"
end
local function ChannelID(name)
local id = GetChannelName(name or CHANNEL)
if id and id > 0 then
return id
end
end
local function Send(text, way)
if way == "CHANNEL" then
local id = ChannelID()
if id and pcall(SendChatMessage, TAG .. " " .. text, "CHANNEL", nil, id) then
counts.channel = counts.channel + 1
end
elseif way then
if pcall(SendAddonMessage, TAG, text, way) then
counts.hidden = counts.hidden + 1
end
end
-- The server is slower to forgive the channel.
local gap = ADDON_GAP
if way == "CHANNEL" then
gap = CHANNEL_GAP
end
timers.next = math.max(timers.next or 0, clock + gap)
end
-- Where a change of ours has to go: the group always, and whoever else is
-- around with DMorph, through their guild if all of them are guild mates.
local function ChangeWays()
local ways = {}
local group = GroupChannel()
if group then
ways[group] = true
end
for name, at in pairs(audience) do
if clock - at > AUDIENCE then
audience[name] = nil
else
ways[Way(name)] = true
end
end
if ways.CHANNEL then
return { CHANNEL = true } -- everyone with DMorph is on it
end
return ways
end
local function OurChannel(name)
if type(name) ~= "string" then
return false
end
name = strupper((string.gsub(name, "^%d+%.%s*", "")))
return name == strupper(CHANNEL) or name == strupper(OLD_CHANNEL)
end
-- No chat window shows DMorph's channel: its messages, joins and notices are
-- dropped before the chat frames see them, whatever channels they listen to.
local function HideChannel()
if M.shareChatHooked or type(ChatFrame_OnEvent) ~= "function" then
return
end
M.shareChatHooked = true
local original = ChatFrame_OnEvent
ChatFrame_OnEvent = function(event)
if type(event) == "string" and strsub(event, 1, 16) == "CHAT_MSG_CHANNEL"
and (OurChannel(arg9) or OurChannel(arg4)) then
return
end
return original(event)
end
end
local function JoinChannel()
HideChannel()
if ChannelID(OLD_CHANNEL) and LeaveChannelByName then
pcall(LeaveChannelByName, OLD_CHANNEL)
end
if not ChannelID() then
pcall(JoinChannelByName, CHANNEL, PASSWORD)
end
for i = 1, (NUM_CHAT_WINDOWS or 7) do
local chatFrame = getglobal("ChatFrame" .. i)
if chatFrame and chatFrame.channelList and ChatFrame_RemoveChannel then
local found = true
while found do
found = nil
for _, name in pairs(chatFrame.channelList) do
if OurChannel(name) then
ChatFrame_RemoveChannel(chatFrame, name)
found = true
break
end
end
end
end
end
end
local function ReadGuild()
inGuild = {}
if not (IsInGuild and IsInGuild()) then
return
end
local ok, count = pcall(GetNumGuildMembers)
for i = 1, (ok and count or 0) do
local name = GetGuildRosterInfo(i)
if name then
inGuild[name] = true
end
end
end
-- Rebuilds the group's names; a newcomer hears our look.
local function ReadGroup()
local before = inGroup
inGroup = {}
local raid = GetNumRaidMembers()
if raid > 0 then
for i = 1, 40 do
local name = UnitName("raid" .. i)
if name then
inGroup[name] = true
end
end
else
for i = 1, 4 do
local name = UnitName("party" .. i)
if name then
inGroup[name] = true
end
end
end
if timers.introduced then
for name in pairs(inGroup) do
if not before[name] then
timers.group = timers.group or clock + 1
break
end
end
end
end
-- Remembered looks -----------------------------------------------------------------
local function Cache()
if not cache then
local account = M.GetAccount()
if type(account.peerCache) ~= "table" then
account.peerCache = {}
end
local realm = (GetRealmName and GetRealmName()) or "?"
if type(account.peerCache[realm]) ~= "table" then
account.peerCache[realm] = {}
end
cache = account.peerCache[realm]
local now = time()
for name, entry in pairs(cache) do
if type(entry) ~= "table" or type(entry.look) ~= "string" or now - (tonumber(entry.seen) or 0) > KEEP then
cache[name] = nil
end
end
end
return cache
end
-- Putting looks on other players -------------------------------------------
local NONE = { items = {} }
-- Only display IDs the client has (a bad one could break its model).
local function Display(text)
local id = Decode(text)
if id and id > 0 and M.GetDisplayName(id) then
return id
end
end
-- A look from its three parts, or nil if they don't read as one.
local function MakeLook(d, m, it)
if not (Decode(d) and Decode(m) and it and (it == "-" or strfind(it, "^[a-s][0-9A-Z]+[a-s0-9A-Z]*$"))) then
return nil
end
local look = { display = Display(d), mount = Display(m), items = {}, d = d, m = m, it = it }
if it ~= "-" then
for letter, id in string.gfind(it, "([a-s])([0-9A-Z]+)") do
local item = Decode(id)
if item and item > 0 and item < 1000000 then
look.items[string.byte(letter) - 96] = item
end
end
end
look.look = d .. " " .. m .. " " .. it
look.print = Fingerprint(look.look)
return look
end
local function IsGUID(token)
return strfind(token, "^0x") ~= nil
end
-- Party, raid and GUID tokens stay with their player; the others don't, so a
-- mount skin only goes on through the first kind (it has to come off the
-- moment that player dismounts).
local function Steady(token)
return IsGUID(token) or strfind(token, "^party%d$") ~= nil or strfind(token, "^raid%d+$") ~= nil
end
-- VanillaHelpers errors on players it can't morph (out of sight, hostile).
local function Call(fn, token, a, b)
if b then
return pcall(fn, token, a, b)
end
return pcall(fn, token, a)
end
-- Puts a player's look on them. `force` sets every part again, for a player
-- the game has just built afresh (their morph is gone on our screen).
local function ApplyTo(name, token)
local peer = peers[name]
local want = NONE
if peer and Seeing() then
want = peer
end
local done = applied[name]
if not done and want == NONE then
return
end
local ok, shown = pcall(UnitDisplayInfo, token)
local force = not done or done.away or (ok and want.display and shown ~= want.display)
if not force and done.version == want.version then
done.scan = scanID
return
end
done = done or { items = {} }
if force or want.display ~= done.display then
local worked = Call(SetUnitDisplayID, token, want.display)
if IsGUID(token) then
guidWorks = worked
end
if not worked then
return
end
done.display = want.display
end
for slot = 1, 19 do
local item = want.items[slot]
if item ~= done.items[slot] or (force and item) then
if Call(SetUnitVisibleItemID, token, slot, item) then
done.items[slot] = item
end
end
end
local mount = want.mount
if mount and not Steady(token) then
mount = done.mount
end
if (mount ~= done.mount or (force and mount)) and type(SetUnitMountDisplayID) == "function" then
if Call(SetUnitMountDisplayID, token, mount) then
done.mount = mount
end
end
done.version, done.scan, done.away = want.version, scanID, nil
if want == NONE and not done.display and not done.mount and not next(done.items) then
applied[name] = nil
else
applied[name] = done
end
end
-- Asks a player for their look; with the fingerprint we have, they only
-- send it all if it changed.
local function Ask(name, print)
if not queued[name] then
table.insert(queue, name)
end
queued[name] = print or true
end
local function Unask(name)
if queued[name] then
queued[name] = nil
for i = 1, table.getn(queue) do
if queue[i] == name then
table.remove(queue, i)
break
end
end
end
end
-- Stores a player's look (new or remembered); returns the peer.
local function SetPeer(name, look, guid, confirmed)
local peer = peers[name]
if not peer then
if peerCount >= MAX_PEERS then
return
end
peerCount = peerCount + 1
end
look.guid = guid or (peer and peer.guid)
look.version = (peer and peer.version or 0) + 1
look.heard = confirmed and clock or -1000
look.confirmed = confirmed
peers[name] = look
if confirmed then
Cache()[name] = { look = look.look, guid = look.guid, seen = time() }
end
return look
end
local function DropPeer(name)
if peers[name] then
peers[name] = nil
peerCount = peerCount - 1
end
Cache()[name] = nil
audience[name] = nil
end
-- A player we heard from earlier, maybe in another session.
local function Remembered(name)
local entry = Cache()[name]
if entry then
local _, _, d, m, it = strfind(entry.look, "^(%S+) (%S+) (%S+)$")
local look = MakeLook(d, m, it)
if look then
return SetPeer(name, look, entry.guid, false)
end
Cache()[name] = nil
end
end
-- A unit token: put a known player's look on, or ask about a new face.
local function Visit(token)
local ok, isPlayer = pcall(UnitIsPlayer, token)
if not (ok and isPlayer) then
return
end
-- A group member far away has a token but no model to morph.
local seen, visible = pcall(UnitIsVisible, token)
if seen and not visible then
return
end
local name = UnitName(token)
if not name or name == UnitName("player") then
return
end
local peer = peers[name]
if not peer and Seeing() and UnitCanAssist("player", token) then
peer = Remembered(name)
end
if peer or applied[name] then
local back = not applied[name] or applied[name].away
ApplyTo(name, token)
if peer then
audience[name] = clock -- they can see us too
if (back or not peer.confirmed) and clock - peer.heard > RECHECK
and clock - (asked[name] or -1000) > RECHECK then
Ask(name, peer.print) -- in case they changed while away
end
end
elseif Seeing() and UnitCanAssist("player", token)
and (not asked[name] or clock - asked[name] > ASK_AGAIN) then
Ask(name)
end
end
local function Scan()
if type(SetUnitDisplayID) ~= "function" then
return
end
scanID = scanID + 1
ReadGroup()
Visit("target")
Visit("mouseover")
Visit("targettarget")
if GetNumRaidMembers() > 0 then
for i = 1, 40 do
Visit("raid" .. i)
end
else
for i = 1, 4 do
Visit("party" .. i)
Visit("party" .. i .. "target")
end
end
-- Without SuperWoW a GUID isn't a unit token, and UnitName finds nothing.
for name, peer in pairs(peers) do
if peer.guid then
local found, unitName = pcall(UnitName, peer.guid)
if found and unitName == name then
Visit(peer.guid)
end
end
end
-- Anyone we didn't see this time may be rebuilt without their look when
-- we next do, so it goes on again in full then.
for _, done in pairs(applied) do
if done.scan ~= scanID then
done.away = true
end
end
end
-- Sends the waiting questions, one message per way.
local function AskQueued()
local byWay, n = {}, 0
while table.getn(queue) > 0 and n < MAX_ASK do
local name = table.remove(queue, 1)
local print = queued[name]
queued[name] = nil
asked[name] = clock
local way = Way(name)
byWay[way] = byWay[way] or {}
if print == true then
table.insert(byWay[way], name)
else
table.insert(byWay[way], name .. ":" .. print)
end
n = n + 1
end
for way, names in pairs(byWay) do
Send("Q " .. table.concat(names, ","), way)
end
end
-- Messages from other clients ---------------------------------------------------
local function ReadLook(sender, rest)
local _, _, d, m, it, guid = strfind(rest, "^(%S+) (%S+) (%S+) ?(%S*)")
local look = MakeLook(d, m, it)
if not look then
return
end
if not strfind(guid or "", "^0x%x+$") then
guid = nil
end
Unask(sender)
asked[sender] = clock
local peer = peers[sender]
if peer and peer.look == look.look then
peer.heard, peer.guid = clock, guid or peer.guid
if not peer.confirmed then
peer.confirmed = true
Cache()[sender] = { look = peer.look, guid = peer.guid, seen = time() }
end
return
end
if SetPeer(sender, look, guid, true) then
Scan()
end
end
-- Mounting or dismounting: only the mount part changed.
local function ReadMount(sender, m)
local peer = peers[sender]
if not (peer and peer.confirmed) then
return
end
local look = MakeLook(peer.d, m, peer.it)
if look and look.look ~= peer.look then
SetPeer(sender, look, nil, true)
Scan()
end
end
-- "Nothing changed": confirms what we remember, else we ask for it all.
local function ReadPrint(sender, print, guid)
Unask(sender)
asked[sender] = clock
local peer = peers[sender]
if peer and peer.print == print then
peer.heard = clock
if strfind(guid or "", "^0x%x+$") then
peer.guid = guid
end
if not peer.confirmed then
peer.confirmed = true
Cache()[sender] = { look = peer.look, guid = peer.guid, seen = time() }
end
else
asked[sender] = nil
Ask(sender)
end
end
local function ReadQuestion(sender, rest, way)
local me = UnitName("player")
for entry in string.gfind(rest, "[^,]+") do
local _, _, name, print = strfind(entry, "^([^:]+):?(.*)$")
if name == me then
if Sharing() then
audience[sender] = clock
if print ~= "" and print == Fingerprint(OwnLook()) then
replies[way] = replies[way] or "H"
else
replies[way] = "L"
end
local at = math.max(clock + 0.2 + math.random() * 0.8, (timers.replied or -100) + REPLY_GAP)
if not timers.reply or timers.reply > at then
timers.reply = at
end
end
elseif way == "CHANNEL" and queued[name] and Way(name) == "CHANNEL" then
-- Someone else asked first: the answer comes on the channel anyway.
Unask(name)
asked[name] = clock
end
end
end
local function Receive(sender, text, way)
if not sender or sender == "" or sender == UnitName("player") then
return
end
local _, _, kind, rest = strfind(text or "", "^(%u) (.*)$")
if kind == "L" then
ReadLook(sender, rest)
elseif kind == "M" then
ReadMount(sender, rest)
elseif kind == "H" then
local _, _, print, guid = strfind(rest, "^(%S+) ?(%S*)")
if print then
ReadPrint(sender, print, guid)
end
elseif kind == "Q" then
ReadQuestion(sender, rest, way)
end
end
-- Your own changes ------------------------------------------------------------
local function OnChange()
local d, m, it = OwnParts()
-- Mounting and dismounting go out at once; other changes wait until
-- they stand still a moment.
if m ~= sent.m then
timers.mount = timers.mount or clock
end
if d ~= sent.d or it ~= sent.it then
timers.first = timers.first or clock
timers.send = math.min(clock + SETTLE, timers.first + MAX_WAIT)
elseif timers.send then
timers.send, timers.first = nil, nil -- changed back before it went out
end
end
local function LookText()
return "L " .. OwnLook() .. " " .. (GUIDOf("player") or "-")
end
-- Tells everyone who needs it; that answers any waiting question too.
local function SendLook(ways)
sent.d, sent.m, sent.it = OwnParts()
timers.send, timers.first, timers.mount = nil, nil, nil
local text = LookText()
for way in pairs(ways) do
Send(text, way)
replies[way] = nil
end
if ways.CHANNEL then
replies = {} -- everyone with DMorph is on it
end
end
-- At most one message (to each way it needs) per pass, the most urgent first.
local function SendNext()
if timers.next and clock < timers.next then
return
end
if timers.mount and clock >= timers.mount then
timers.mount = nil
local _, m = OwnParts()
if m ~= sent.m then
sent.m = m
for way in pairs(ChangeWays()) do
Send("M " .. m, way)
end
end
elseif timers.send and clock >= timers.send then
SendLook(ChangeWays())
elseif timers.reply and clock >= timers.reply then
timers.reply, timers.replied = nil, clock
local look = OwnLook()
for way, kind in pairs(replies) do
replies[way] = nil
if kind == "L" then
Send(LookText(), way)
else
Send("H " .. Fingerprint(look) .. " " .. (GUIDOf("player") or "-"), way)
end
end
elseif table.getn(queue) > 0 and clock >= (timers.query or 0) then
timers.query = clock + QUERY_GAP
AskQueued()
end
end
-- Remembered players who don't answer have stopped using DMorph.
local function ForgetSilent()
for name, peer in pairs(peers) do
if not peer.confirmed and asked[name] and not queued[name] and clock - asked[name] > CONFIRM_WAIT then
DropPeer(name)
end
end
end
local function Tick()
if timers.join and clock >= timers.join then
timers.join = nil
JoinChannel()
timers.ready = clock + READY_DELAY -- joining takes a moment
end
if clock >= (timers.scan or 0) then
timers.scan = clock + SCAN_GAP
Scan()
end
if clock >= (timers.guild or 0) then
timers.guild = clock + GUILD_GAP
if IsInGuild and IsInGuild() and GuildRoster then
pcall(GuildRoster)
end
end
-- Nothing goes out before the channel is joined.
if not (timers.ready and clock >= timers.ready) then
return
end
if not timers.introduced then
-- What we look like now is what everyone will learn by asking.
timers.introduced = true
sent.d, sent.m, sent.it = OwnParts()
timers.send, timers.first, timers.mount = nil, nil, nil
timers.group = clock
end
if timers.group and clock >= timers.group and not (timers.next and clock < timers.next) then
-- Only the group hears it: anyone else asks when they see us.
timers.group = nil
local group = GroupChannel()
if group then
Send(LookText(), group)
end
end
SendNext()
ForgetSilent()
end
local frame = CreateFrame("Frame")
frame:RegisterEvent("PLAYER_ENTERING_WORLD")
frame:RegisterEvent("CHAT_MSG_CHANNEL")
frame:RegisterEvent("CHAT_MSG_ADDON")
frame:RegisterEvent("PLAYER_TARGET_CHANGED")
frame:RegisterEvent("UPDATE_MOUSEOVER_UNIT")
frame:RegisterEvent("PARTY_MEMBERS_CHANGED")
frame:RegisterEvent("RAID_ROSTER_UPDATE")
frame:RegisterEvent("GUILD_ROSTER_UPDATE")
frame:SetScript("OnEvent", function()
if event == "CHAT_MSG_CHANNEL" then
-- arg9 is the channel's name, arg4 the same with its number.
if OurChannel(arg9) or OurChannel(arg4) then
local _, _, text = strfind(arg1 or "", "^" .. TAG .. " (.*)$")
if text then
Receive(arg2, text, "CHANNEL")
end
end
elseif event == "CHAT_MSG_ADDON" then
if arg1 == TAG then
Receive(arg4, arg2, arg3)
end
elseif event == "PLAYER_TARGET_CHANGED" then
Visit("target")
elseif event == "UPDATE_MOUSEOVER_UNIT" then
Visit("mouseover")
elseif event == "GUILD_ROSTER_UPDATE" then
ReadGuild()
elseif event == "PLAYER_ENTERING_WORLD" then
-- After each loading screen everyone around is built afresh, and we
-- rejoin if needed.
for _, done in pairs(applied) do
done.away = true
end
timers.join = clock + JOIN_DELAY
timers.guild = clock + 1
Cache() -- forgets old looks
else
ReadGroup()
end
end)
frame:SetScript("OnUpdate", function()
clock = clock + arg1
this.wait = (this.wait or 0) - arg1
if this.wait <= 0 then
this.wait = TICK
Tick()
end
end)
M.RegisterListener(OnChange)
-- Settings and chat command -------------------------------------------------------
-- Whether you share and see, how many players with DMorph you know of, how
-- many of them are morphed, whether GUIDs work as tokens (nil: untried), and
-- how many messages went out on the channel and hidden.
function M.GetShareStatus()
local morphed = 0
for _, peer in pairs(peers) do
if peer.display or peer.mount or next(peer.items) then
morphed = morphed + 1
end
end
return Sharing(), Seeing(), peerCount, morphed, guidWorks, counts.channel, counts.hidden
end
function M.SetSharing(on)
M.GetAccount().shareOff = (not on) or nil
-- The others hear at once, so they take your morph off when you stop.
OnChange()
timers.send = clock
if on then
return true, "Other DMorph users now see your morph."
end
return true, "Other DMorph users no longer see your morph."
end
function M.SetSeeing(on)
M.GetAccount().othersOff = (not on) or nil
-- Looks come off (or go on) as their players come by.
for _, done in pairs(applied) do
done.away = true
end
Scan()
if on then
return true, "You now see other DMorph users' morphs."
end
return true, "You no longer see other DMorph users' morphs (they come off as you see each player)."
end
local function Report(ok, message)
DEFAULT_CHAT_FRAME:AddMessage("|cff33ff99DMorph|r: " .. message)
end
M.commands.share = function(args)
local first, second = strlower(args[1] or ""), strlower(args[2] or "")
if first == "on" or first == "off" then
return Report(M.SetSharing(first == "on"))
elseif first == "others" and (second == "on" or second == "off") then
return Report(M.SetSeeing(second == "on"))
end
local sharing, seeing, known, morphed, guids, onChannel, hidden = M.GetShareStatus()
local guidText = "not tried yet"
if guids == true then
guidText = "yes, nearby players show without a target"
elseif guids == false then
guidText = "no, target or mouse over players to show them"
end
Report(true, "Others see your morph: " .. (sharing and "on" or "off") .. ". You see theirs: "
.. (seeing and "on" or "off") .. ". DMorph users seen: " .. known .. " (" .. morphed .. " morphed).")
Report(true, "SuperWoW GUIDs: " .. guidText .. ".")
Report(true, "Messages sent this session: " .. onChannel .. " on the channel, " .. hidden
.. " hidden to your group or guild.")
Report(true, "Usage: .share on/off, .share others on/off. Only friendly players can be morphed.")
end