Freewood/Freewood-OctoWoW-Codex
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9147ef7737c1a305a13ea1b4d672ba3f524ba712
Freewood-OctoWoW-Codex/CodexTaxi.lua
T
Freewood 9147ef7737 Dateien nach "/" hochladen
2026-10-27 14:09:21 +00:00

506 lines
19 KiB
Lua
Raw Blame History

-- Freewood-OctoWoW-Codex: Flugrouten (Taxi)
--
-- Erfasst beim Flug: Start- und Zielpunkt, die Strecke (Punkte alle paar Sekunden), die Flugdauer und den bezahlten Preis.
-- Je Charakter: welche Flugpunkte er kennt, wie viel Gold er fuer Fluege ausgegeben hat und wie oft er geflogen ist.
--
-- db.taxi.nodes[id] = { n = Name, w = Welt, tx, ty = Position auf der Flugkarte, a, b = Weltposition (erster, zweiter Wert von UnitPosition) }
-- db.taxi.routes[id] = { a = Start-ID, b = Ziel-ID, t = Sekunden, c = Preis in Kupfer, n = Anzahl, p = { a1, b1, a2, b2, ... }, upd = Stand }
-- db.taxiChar[Charakter] = { known = { [id] = true }, spent = Kupfer, trips = Anzahl, log = { { t, a, b, c, d }, ... } }
-- Die Flugpunkt-ID kommt aus der Position auf der Flugkarte (sprachunabhaengig), sonst aus dem Namen.
-- Zwischenlandungen: aufgezeichnet wird die Gesamtstrecke bis zum gewaehlten Ziel.
local ADDON, NS = ...
local FW = _G.Freewood
local Codex = NS and NS.Codex
if not FW or not Codex then
return
end
local Taxi = { state = {} }
Codex.Taxi = Taxi
NS.Taxi = Taxi
local state = Taxi.state
local SAMPLE = 3 -- Sekunden zwischen zwei Streckenpunkten
local MAX_POINTS = 120 -- Punkte je Route (je 2 Zahlen)
local MAX_ROUTES = 600
local MAX_NODES = 300
local MAX_LOG = 30
local PRICE_WINDOW = 6 -- Sekunden nach dem Start, in denen der abgezogene Betrag nachgemessen wird
local function Clock() return _G.GetTime and _G.GetTime() or 0 end
local function Now() return _G.time and _G.time() or 0 end
local function Round(v) return math.floor((v or 0) + 0.5) end
local function DB()
local db = Codex.db
if not db then return nil end
local t = db.taxi
if type(t) ~= "table" then t = {}; db.taxi = t end
t.nodes = t.nodes or {}
t.routes = t.routes or {}
return t
end
local function CharRec(create)
local db = Codex.db
local key = Codex.Trust and Codex.Trust.SelfKey and Codex.Trust.SelfKey() or nil
if not db or not key then return nil end
db.taxiChar = db.taxiChar or {}
local r = db.taxiChar[key]
if not r and create ~= false then
r = { known = {}, spent = 0, trips = 0, log = {} }
db.taxiChar[key] = r
end
return r
end
function Taxi.Money(c)
c = math.floor(tonumber(c) or 0)
local g, s, k = math.floor(c / 10000), math.floor(c / 100) % 100, c % 100
local out = {}
if g > 0 then out[#out + 1] = g .. "g" end
if s > 0 then out[#out + 1] = s .. "s" end
if k > 0 or #out == 0 then out[#out + 1] = k .. "c" end
return table.concat(out, " ")
end
function Taxi.Duration(sec)
sec = math.floor(tonumber(sec) or 0)
return string.format("%d:%02d", math.floor(sec / 60), sec % 60)
end
------------------------------------------------------------------------
-- Abfragen (fuer Karte und Planer)
------------------------------------------------------------------------
Taxi.rev = 0
local merged
-- Eigene und empfangene Routen zusammen (eigene haben Vorrang)
function Taxi.Routes()
local t = DB()
if not t then return {} end
local rem = Codex.db.taxir
if not rem or next(rem) == nil then return t.routes end
if merged and merged.rev == Taxi.rev then return merged.routes end
local out = {}
for k, r in pairs(rem) do out[k] = r end
for k, r in pairs(t.routes) do out[k] = r end
merged = { rev = Taxi.rev, routes = out }
return out
end
function Taxi.Node(id)
local t = DB()
if not t then return nil end
local n = t.nodes[id]
if n then return n end
local rn = Codex.db.taxin
return rn and rn[id] or nil
end
-- Kennt dieser Charakter den Flugpunkt?
function Taxi.Known(id)
local c = CharRec(false)
return c and c.known and c.known[id] and true or false
end
function Taxi.CharStats()
local c = CharRec(false)
if not c then return nil end
local n = 0
for _ in pairs(c.known or {}) do n = n + 1 end
return { known = n, spent = c.spent or 0, trips = c.trips or 0, secs = c.secs or 0, log = c.log, routes = c.rt }
end
-- Wie oft dieser Charakter die Route geflogen ist und wie lange insgesamt: n, Sekunden
function Taxi.RouteStat(a, b)
local c = CharRec(false)
local r = c and c.rt and c.rt[a .. ">" .. b]
if not r then return 0, 0 end
return r.n or 0, r.sec or 0
end
------------------------------------------------------------------------
-- Flugkarte lesen
------------------------------------------------------------------------
local function NodeId(i, world)
if _G.TaxiNodePosition then
local ok, x, y = pcall(_G.TaxiNodePosition, i)
if ok and type(x) == "number" and type(y) == "number" then
return string.format("%d:%d:%d", world or 0, Round(x * 1000), Round(y * 1000)), x, y
end
end
local name = _G.TaxiNodeName and _G.TaxiNodeName(i)
if type(name) == "string" and name ~= "" then return "n:" .. name, nil, nil end
return nil
end
-- Kartenposition des Flugpunkts (Karte, x, y), solange der Spieler dort steht; fuer den Levelplaner
local function SetMapPos(n)
local loc = FW.Util and FW.Util.GetPlayerLocation and FW.Util.GetPlayerLocation()
if loc and loc.mapID and loc.x and loc.y and loc.x > 0 and loc.y > 0 then
if n.m ~= loc.mapID or not n.x then
n.m, n.x, n.y = loc.mapID, loc.x, loc.y
return true
end
end
return false
end
function Taxi.Scan()
local count = _G.NumTaxiNodes and _G.NumTaxiNodes() or 0
if type(count) ~= "number" or count <= 0 then return end
local T, C = DB(), CharRec(true)
if not T or not C then return end
local P = Codex.Path and Codex.Path.Read and Codex.Path.Read()
local world = P and P.world or 0
local nodes = 0
for _ in pairs(T.nodes) do nodes = nodes + 1 end
state.slot, state.cur = {}, nil
local changed = false
for i = 1, math.min(count, 120) do
local kind = _G.TaxiNodeGetType and _G.TaxiNodeGetType(i)
local name = _G.TaxiNodeName and _G.TaxiNodeName(i)
local id, tx, ty = NodeId(i, world)
if id then
local n = T.nodes[id]
if not n and nodes < MAX_NODES then
n = {}
T.nodes[id] = n
nodes = nodes + 1
end
if n then
if type(name) == "string" and name ~= "" then n.n = name:sub(1, 60) end
n.w, n.tx, n.ty = world, tx, ty
end
if kind ~= "NONE" and not C.known[id] then C.known[id] = true; changed = true end
if kind == "CURRENT" then
state.cur = id
if n and P then n.a, n.b = Round(P.y), Round(P.x) end
if n and SetMapPos(n) then changed = true end
end
local cost = _G.TaxiNodeCost and tonumber(_G.TaxiNodeCost(i)) or nil
state.slot[i] = { id = id, cost = cost and math.floor(cost) or nil, kind = kind }
end
end
if changed then
Taxi.rev = Taxi.rev + 1
FW:Fire("CODEX_TAXI_CHANGED")
end
if Taxi.OnOpen then pcall(Taxi.OnOpen) end
end
------------------------------------------------------------------------
-- Teilen (Share/Sync, Datensatzart "f", je Route ein Datensatz)
------------------------------------------------------------------------
-- Zahl zur Route: Flugpunkt-Zahl (Welt, x, y) * 10^7 + Flugpunkt-Zahl des Ziels. Nur Flugpunkte mit Positions-ID sind teilbar.
local NODE_W = 1002001
local SHARE_POINTS = 40
local function NodeNum(id)
local w, x, y = tostring(id):match("^(%d+):(%d+):(%d+)$")
w, x, y = tonumber(w), tonumber(x), tonumber(y)
if not w or w > 8 or x > 1000 or y > 1000 then return nil end
return w * NODE_W + x * 1001 + y
end
local function NodeFromNum(n)
if type(n) ~= "number" or n < 0 or n >= 9 * NODE_W then return nil end
local w, r = math.floor(n / NODE_W), n % NODE_W
return string.format("%d:%d:%d", w, math.floor(r / 1001), r % 1001)
end
local function RouteNum(a, b)
local na, nb = NodeNum(a), NodeNum(b)
if not na or not nb then return nil end
return na * 10000000 + nb
end
local function RouteIds(num)
local a, b = NodeFromNum(math.floor(num / 10000000)), NodeFromNum(num % 10000000)
if not a or not b then return nil end
return a, b
end
function Taxi.SyncList()
local out = {}
local t = DB()
if not t then return out end
for _, r in pairs(t.routes) do
local num = r.upd and RouteNum(r.a, r.b)
if num then out[#out + 1] = { key = "f" .. string.format("%.0f", num), upd = r.upd } end
end
return out
end
local function NodeShare(id)
local n = Taxi.Node(id) or {}
return { n = n.n, a = n.a, b = n.b, m = n.m, x = n.x, y = n.y }
end
-- Eigene Route als Datensatz (Strecke auf hoechstens SHARE_POINTS Punkte verkleinert)
function Taxi.RouteRecord(num)
local a, b = RouteIds(num)
local t = DB()
local r = a and t and t.routes[a .. ">" .. b]
if not r or not r.upd or type(r.p) ~= "table" then return nil end
local pts, m = {}, math.floor(#r.p / 2)
if m < 2 then return nil end
local take = math.min(m, SHARE_POINTS)
for i = 1, take do
local j = (take == 1) and 1 or (1 + math.floor((i - 1) * (m - 1) / (take - 1) + 0.5))
pts[#pts + 1] = r.p[j * 2 - 1]
pts[#pts + 1] = r.p[j * 2]
end
return { t = r.t, c = r.c, n = r.n or 1, p = pts, A = NodeShare(a), B = NodeShare(b) }, r.upd
end
local function NodeFromRecord(id, rn)
local w, x, y = tostring(id):match("^(%d+):(%d+):(%d+)$")
return { n = rn.n, w = tonumber(w), tx = tonumber(x) / 1000, ty = tonumber(y) / 1000, a = rn.a, b = rn.b, m = rn.m, x = rn.x, y = rn.y }
end
-- Empfangene Route einmischen. Rueckgabe: true, wenn gespeichert
function Taxi.StoreRemote(rec)
local db = Codex.db
if not db or type(rec) ~= "table" then return false end
local a, b = RouteIds(rec.id)
if not a then return false end
db.taxir = db.taxir or {}
db.taxin = db.taxin or {}
local rid = a .. ">" .. b
local old = db.taxir[rid]
if old and (old.upd or 0) >= rec.upd then return false end
if not old then
local count = 0
for _ in pairs(db.taxir) do count = count + 1 end
if count >= MAX_ROUTES then return false end
end
db.taxir[rid] = { a = a, b = b, t = rec.t, c = rec.c, n = rec.n, p = rec.p, upd = rec.upd }
local own = DB()
for id, rn in pairs({ [a] = rec.A, [b] = rec.B }) do
if not (own and own.nodes[id]) and not db.taxin[id] then
local nodes = 0
for _ in pairs(db.taxin) do nodes = nodes + 1 end
if nodes < MAX_NODES then db.taxin[id] = NodeFromRecord(id, rn) end
end
end
Taxi.rev = Taxi.rev + 1
return true
end
-- Levelplaner: Fluege als Kanten { id, k, t, wait, from = { m, x, y }, to = { m, x, y } }, nur zwischen Flugpunkten,
-- die dieser Charakter kennt und deren Kartenposition bekannt ist
function Taxi.PlannerOn()
local db = Codex.db
return not (db and db.settings and db.settings.taxiPlan == false)
end
local edgeCache
function Taxi.Edges()
if not Taxi.PlannerOn() then return {} end
local key = Codex.Trust and Codex.Trust.SelfKey and Codex.Trust.SelfKey() or "?"
if edgeCache and edgeCache.rev == Taxi.rev and edgeCache.key == key then return edgeCache.list end
local list = {}
for rid, r in pairs(Taxi.Routes()) do
local na, nb = Taxi.Node(r.a), Taxi.Node(r.b)
if na and nb and na.m and nb.m and r.t and Taxi.Known(r.a) and Taxi.Known(r.b) then
list[#list + 1] = { id = "f" .. rid, k = "flight", t = r.t, wait = 20, name = nb.n, fa = r.a, fb = r.b,
from = { m = na.m, x = na.x, y = na.y }, to = { m = nb.m, x = nb.x, y = nb.y } }
end
end
edgeCache = { rev = Taxi.rev, key = key, list = list }
return list
end
function Taxi.ClearRemote()
local db = Codex.db
if db then db.taxir, db.taxin = nil, nil end
Taxi.rev = Taxi.rev + 1
end
------------------------------------------------------------------------
-- Flug erfassen
------------------------------------------------------------------------
local function OnTake(slot)
local s = state.slot and state.slot[slot]
if not s or not state.cur then return end
state.pending = { from = state.cur, to = s.id, quote = s.cost or 0, money0 = _G.GetMoney and _G.GetMoney() or 0,
asked = Clock(), started = false }
end
local function Finish(p, now)
state.pending = nil
Taxi.flight = nil
local T, C = DB(), CharRec(true)
if not T or not C then return end
local dur = now - p.t0
if dur < 5 then return end
-- Endpunkt: Position der Landung
local P = Codex.Path and Codex.Path.Read and Codex.Path.Read()
if P then
p.pts[#p.pts + 1] = Round(P.y)
p.pts[#p.pts + 1] = Round(P.x)
local n = T.nodes[p.to]
if n and not n.a then n.a, n.b = Round(P.y), Round(P.x) end
if n and not n.m then SetMapPos(n) end
end
local paid = p.paid or 0
if paid <= 0 or paid > p.quote * 3 + 100 then paid = p.quote or 0 end
local rid = p.from .. ">" .. p.to
local r = T.routes[rid]
local isNew = false
if not r then
local count = 0
for _ in pairs(T.routes) do count = count + 1 end
if count >= MAX_ROUTES then return end
r = { a = p.from, b = p.to, t = Round(dur), c = paid, n = 1, p = p.pts, upd = Now() }
T.routes[rid] = r
isNew = true
else
r.n = (r.n or 1) + 1
r.t = Round((r.t * (r.n - 1) + dur) / r.n)
r.c = paid
if #p.pts > #(r.p or {}) then r.p = p.pts end
r.upd = Now()
end
C.known[p.to] = true
C.spent = (C.spent or 0) + paid
C.trips = (C.trips or 0) + 1
C.secs = (C.secs or 0) + Round(dur)
C.rt = C.rt or {}
local rs = C.rt[rid]
if not rs then rs = { n = 0, sec = 0, gold = 0 }; C.rt[rid] = rs end
rs.n, rs.sec, rs.gold = rs.n + 1, rs.sec + Round(dur), (rs.gold or 0) + paid
C.log = C.log or {}
C.log[#C.log + 1] = { t = Now(), a = p.from, b = p.to, c = paid, d = Round(dur) }
while #C.log > MAX_LOG do table.remove(C.log, 1) end
if isNew then
local na, nb = T.nodes[p.from], T.nodes[p.to]
FW:Print(string.format("Codex: Flugroute %s -> %s gespeichert (%s, %s, %d Punkte)",
na and na.n or p.from, nb and nb.n or p.to, Taxi.Duration(dur), Taxi.Money(paid), math.floor(#p.pts / 2)))
end
Taxi.rev = Taxi.rev + 1
FW:Fire("CODEX_TAXI_CHANGED")
FW:Fire("CODEX_CHANGED", "taxi")
end
local function Tick()
local p = state.pending
if not p then return end
local now = Clock()
local on = _G.UnitOnTaxi and _G.UnitOnTaxi("player") and true or false
if on and not p.started then
p.started, p.t0, p.nextAt, p.pts = true, now, now, {}
local r = Taxi.Routes()[p.from .. ">" .. p.to]
local nd = Taxi.Node(p.to)
Taxi.flight = { t0 = now, exp = r and r.t or nil, name = nd and nd.n or "?" }
end
if p.started then
if on then
if now - p.t0 <= PRICE_WINDOW then
local d = p.money0 - (_G.GetMoney and _G.GetMoney() or 0)
if d > (p.paid or 0) then p.paid = d end
end
if now >= p.nextAt and #p.pts < MAX_POINTS * 2 then
local P = Codex.Path and Codex.Path.Read and Codex.Path.Read()
if P then
p.pts[#p.pts + 1] = Round(P.y)
p.pts[#p.pts + 1] = Round(P.x)
end
p.nextAt = now + SAMPLE
end
else
Finish(p, now)
end
elseif now - p.asked > 15 then
state.pending = nil -- Flug nicht angetreten
Taxi.flight = nil
end
end
local acc = 0
local frame = _G.CreateFrame and _G.CreateFrame("Frame")
if frame then
frame:SetScript("OnUpdate", function(_, elapsed)
acc = acc + (elapsed or 0)
if acc < 1 then return end
acc = 0
pcall(Tick)
end)
end
-- Tooltip am Flugziel auf der Flugkarte: Reisedauer (und wie oft schon geflogen)
function Taxi.ButtonTip(button)
if not (button and button.GetID and state.cur and state.slot) then return end
local s = state.slot[button:GetID()]
local tt = _G.GameTooltip
if not s or not tt or s.id == state.cur then return end
local r = Taxi.Routes()[state.cur .. ">" .. s.id]
local L = FW.L
if r and r.t then
tt:AddLine(string.format(L.CODEX_TAXI_TIP_TIME, Taxi.Duration(r.t)), 0.94, 0.75, 0.36)
else
tt:AddLine(L.CODEX_TAXI_TIP_NONE, 0.6, 0.59, 0.55)
end
local n, sec = Taxi.RouteStat(state.cur, s.id)
if n > 0 then
tt:AddLine(string.format(L.CODEX_TAXI_TIP_COUNT, n, Taxi.Duration(sec)), 0.6, 0.59, 0.55)
end
tt:Show()
end
local function Install()
if Taxi.hooked then return end
Taxi.hooked = true
if _G.hooksecurefunc and _G.TaxiNodeOnButtonEnter then
pcall(_G.hooksecurefunc, "TaxiNodeOnButtonEnter", function(button) pcall(Taxi.ButtonTip, button) end)
end
if _G.hooksecurefunc and _G.TakeTaxiNode then
pcall(_G.hooksecurefunc, "TakeTaxiNode", function(slot) pcall(OnTake, slot) end)
end
FW:RegisterEvent("TAXIMAP_OPENED", function() pcall(Taxi.Scan) end, Taxi)
end
Install()
------------------------------------------------------------------------
-- /fwtaxi
------------------------------------------------------------------------
SLASH_FREEWOODTAXI1 = "/fwtaxi"
SlashCmdList["FREEWOODTAXI"] = function(arg)
local T = DB()
if not T then return end
local nodes, routes = 0, 0
for _ in pairs(T.nodes) do nodes = nodes + 1 end
for _ in pairs(T.routes) do routes = routes + 1 end
if arg == "diag" then
FW:Print(string.format("Taxi: TakeTaxiNode=%s TaxiNodePosition=%s TaxiNodeCost=%s TaxiNodeGetType=%s UnitOnTaxi=%s Hook=%s",
tostring(_G.TakeTaxiNode ~= nil), tostring(_G.TaxiNodePosition ~= nil), tostring(_G.TaxiNodeCost ~= nil),
tostring(_G.TaxiNodeGetType ~= nil), tostring(_G.UnitOnTaxi ~= nil), tostring(Taxi.hooked)))
FW:Print(string.format("Taxi: aktueller Punkt=%s, Plaetze=%d, Flug laeuft=%s", tostring(state.cur), state.slot and #state.slot or 0,
tostring(state.pending and state.pending.started or false)))
return
end
local c = Taxi.CharStats()
FW:Print(string.format("Taxi: %d Flugpunkte, %d Routen gespeichert.", nodes, routes))
if c then
FW:Print(string.format("Taxi: dieser Charakter kennt %d Flugpunkte, %d Fluege, %s ausgegeben, %s in der Luft.", c.known, c.trips, Taxi.Money(c.spent), Taxi.Duration(c.secs)))
end
local list = {}
for _, r in pairs(T.routes) do list[#list + 1] = r end
table.sort(list, function(x, y) return (x.upd or 0) > (y.upd or 0) end)
for i = 1, math.min(#list, 5) do
local r = list[i]
local na, nb = T.nodes[r.a], T.nodes[r.b]
FW:Print(string.format(" %s -> %s: %s, %s, %d Punkte, %dx", na and na.n or r.a, nb and nb.n or r.b, Taxi.Duration(r.t), Taxi.Money(r.c),
math.floor(#(r.p or {}) / 2), r.n or 1))
end
end
Reference in New Issue View Git Blame Copy Permalink