965e8589c9
I implemented a QuestHelper_GetTime function for the next time Blizzard decides to fiddle with the time functions. It returns debugprofilestop() / 1000, to exactly match the precision of GetTime(). I also re-removed references to Cartographer from the rollback.
285 lignes
7,6 Kio
Lua
285 lignes
7,6 Kio
Lua
|
|
local GetTime = QuestHelper_GetTime
|
|
|
|
QuestHelper_File["db_get.lua"] = "4.0.1.$svnversion$"
|
|
QuestHelper_Loadtime["db_get.lua"] = GetTime()
|
|
|
|
local dev_mode = (QuestHelper_File["db_get.lua"] == "Development Version")
|
|
QHDB_Export = {}
|
|
local export = false
|
|
-- yoink
|
|
--[[
|
|
local QHDB_temp = QHDB
|
|
QHDB = nil
|
|
local QHDB = QHDB_temp]]
|
|
QuestHelper: Assert(#QHDB == 4, "Please make sure that you are loading a locale.")
|
|
|
|
local weak_v = { __mode = 'v' }
|
|
local weak_k = { __mode = 'k' }
|
|
|
|
local cache = {}
|
|
|
|
local frequencies = setmetatable({}, weak_k)
|
|
|
|
-- guhhh just want this to work
|
|
local freq_group = setmetatable({}, weak_k)
|
|
local freq_id = setmetatable({}, weak_k)
|
|
|
|
local function DBC_Get(group, id)
|
|
if not cache[group] then return end
|
|
return cache[group][id]
|
|
end
|
|
|
|
local function DBC_Put(group, id, item)
|
|
if not cache[group] then cache[group] = setmetatable({}, weak_v) end
|
|
QuestHelper: Assert(not cache[group][id])
|
|
cache[group][id] = item
|
|
|
|
--DB_how_many_are_used()
|
|
end
|
|
|
|
local function mark(tab, tomark)
|
|
for k, v in pairs(tab) do
|
|
if k ~= "__owner" and type(v) == "table" then
|
|
mark(v, tomark)
|
|
end
|
|
end
|
|
tab.__owner = tomark
|
|
end
|
|
|
|
local function read_adaptint(data, offset)
|
|
local stx = 0
|
|
local acu = 1
|
|
while true do
|
|
local v = strbyte(data, offset)
|
|
QuestHelper: Assert(v, string.format("%d %d", #data, offset))
|
|
stx = stx + acu * math.floor(v / 2)
|
|
offset = offset + 1
|
|
acu = acu * 128
|
|
if mod(v, 2) == 0 then break end
|
|
end
|
|
return stx, offset
|
|
end
|
|
|
|
local function search_index(index, data, item)
|
|
--[[Header format:
|
|
|
|
Itemid (0 for endnode)
|
|
Offset
|
|
Length
|
|
Rightlink]]
|
|
|
|
local cofs = 1
|
|
--[[ assert(index and type(index) == "string") ]]
|
|
--[[ assert(data and type(data) == "string") ]]
|
|
|
|
while true do
|
|
local idx, ofs, len, rlink
|
|
idx, cofs = read_adaptint(index, cofs)
|
|
if idx == 0 then return end
|
|
ofs, cofs = read_adaptint(index, cofs)
|
|
len, cofs = read_adaptint(index, cofs)
|
|
rlink, cofs = read_adaptint(index, cofs)
|
|
|
|
if idx == item then
|
|
return strsub(data, ofs, ofs + len)
|
|
end
|
|
|
|
if idx < item then cofs = cofs + rlink end
|
|
end
|
|
end
|
|
|
|
local initted = false
|
|
function DB_Init()
|
|
QuestHelper: Assert(not initted)
|
|
for _, db in ipairs(QHDB) do
|
|
for _, v in pairs(db) do
|
|
--print("db", not not v.__dictionary, not not v.__tokens)
|
|
if v.__dictionary and v.__tokens then
|
|
local redictix = v.__dictionary
|
|
if not redictix:find("\"") then redictix = redictix .. "\"" end
|
|
if not redictix:find(",") then redictix = redictix .. "," end
|
|
if not redictix:find("\\") then redictix = redictix .. "\\" end
|
|
local tokens = loadstring("return {" .. QH_LZW_Decompress_Dicts_Arghhacky(v.__tokens, redictix) .. "}")()
|
|
QuestHelper: Assert(tokens)
|
|
|
|
local _, _, prep = QH_LZW_Prepare_Arghhacky(v.__dictionary, tokens)
|
|
QuestHelper: Assert(prep)
|
|
|
|
QuestHelper: Assert(type(prep) == "table")
|
|
|
|
v.__tokens = prep
|
|
end
|
|
end
|
|
end
|
|
initted = true
|
|
QH_UpdateQuests() -- just in case it's been waiting on us (it has almost certainly been waiting on us)
|
|
end
|
|
|
|
function DB_Ready()
|
|
return initted
|
|
end
|
|
|
|
function DB_HasItem(group, id)
|
|
QuestHelper: Assert(initted)
|
|
|
|
for _, db in ipairs(QHDB) do
|
|
if db[group] then
|
|
if db[group][id] then
|
|
return true
|
|
end
|
|
|
|
if type(id) == "number" and id > 0 and db[group].__serialize_index and db[group].__serialize_data and search_index(db[group].__serialize_index, db[group].__serialize_data, id) then
|
|
return true
|
|
end
|
|
end
|
|
end
|
|
|
|
return false
|
|
end
|
|
|
|
function DB_GetItem(group, id, silent, register)
|
|
QuestHelper: Assert(initted)
|
|
|
|
QuestHelper: Assert(group, string.format("%s %s", tostring(group), tostring(id)))
|
|
QuestHelper: Assert(id, string.format("%s %s", tostring(group), tostring(id)))
|
|
local ite = DBC_Get(group, id)
|
|
|
|
if not ite then
|
|
if type(id) == "string" then QuestHelper: Assert(not id:match("__.*")) end
|
|
|
|
--QuestHelper:TextOut(string.format("%s %d", group, id))
|
|
|
|
for _, db in ipairs(QHDB) do
|
|
--print(db, db[group], db[group] and db[group][id], type(group), type(id))
|
|
if db[group] then
|
|
local dat
|
|
if db[group][id] then
|
|
dat = db[group][id]
|
|
end
|
|
|
|
--print(not dat, type(id), id, not not db[group].__serialize_index, not not db[group].__serialize_index)
|
|
if not dat and type(id) == "number" and id > 0 and db[group].__serialize_index and db[group].__serialize_data then
|
|
dat = search_index(db[group].__serialize_index, db[group].__serialize_data, id)
|
|
end
|
|
|
|
if dat then
|
|
if not ite then ite = QuestHelper:CreateTable("db") end
|
|
|
|
local srctab
|
|
|
|
if type(dat) == "string" then
|
|
QuestHelper: Assert(db[group].__tokens == nil or type(db[group].__tokens) == "table")
|
|
srctab = loadstring("return {" .. (db[group].__prefix or "") .. QH_LZW_Decompress_Dicts_Prepared_Arghhacky(dat, db[group].__dictionary, nil, db[group].__tokens) .. (db[group].__suffix or "") .. "}")()
|
|
elseif type(dat) == "table" then
|
|
srctab = dat
|
|
else
|
|
QuestHelper: Assert()
|
|
end
|
|
|
|
for k, v in pairs(srctab) do
|
|
QuestHelper: Assert(not ite[k] or k == "used")
|
|
ite[k] = v
|
|
if export then
|
|
if not QHDB_Export[group] then QHDB_Export[group] = {} end
|
|
if not QHDB_Export[group][id] then QHDB_Export[group][id] = {} end
|
|
QHDB_Export[group][id][k] = v
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if ite then
|
|
--print("marking", group, id, silent, register)
|
|
mark(ite, ite)
|
|
--print("done marking")
|
|
|
|
DBC_Put(group, id, ite)
|
|
|
|
freq_group[ite] = group
|
|
freq_id[ite] = id
|
|
else
|
|
if not silent then
|
|
QuestHelper:TextOut(string.format("Tried to get %s/%s, failed", tostring(group), tostring(id)))
|
|
end
|
|
end
|
|
end
|
|
|
|
if ite then
|
|
frequencies[ite] = (frequencies[ite] or 0) + (register and 1 or 1000000000) -- effectively infinity
|
|
end
|
|
|
|
return ite
|
|
end
|
|
|
|
local function incinerate(ite, crunchy)
|
|
if dev_mode then return end -- wellllp
|
|
|
|
if not crunchy[ite] then
|
|
crunchy[ite] = true
|
|
|
|
for k, v in pairs(ite) do
|
|
if type(k) == "table" then incinerate(k, crunchy) end
|
|
if type(v) == "table" then incinerate(v, crunchy) end
|
|
end
|
|
end
|
|
end
|
|
|
|
function DB_ReleaseItem(ite)
|
|
QuestHelper: Assert(ite)
|
|
frequencies[ite] = frequencies[ite] - 1
|
|
|
|
if frequencies[ite] == 0 then
|
|
--print("incinerating", freq_group[ite], freq_id[ite])
|
|
cache[freq_group[ite]][freq_id[ite]] = nil
|
|
freq_group[ite] = nil
|
|
freq_id[ite] = nil
|
|
|
|
local incin = QuestHelper:CreateTable("incinerate")
|
|
incinerate(ite, incin)
|
|
for k, _ in pairs(incin) do
|
|
QuestHelper:ReleaseTable(k)
|
|
end -- burn baby burn
|
|
QuestHelper:ReleaseTable(incin)
|
|
end
|
|
end
|
|
|
|
function DB_ListItems(group)
|
|
local tab = {}
|
|
for _, db in ipairs(QHDB) do
|
|
if db[group] then
|
|
QuestHelper: Assert(not db.__serialize_index and not db.__serialize_data)
|
|
for k, _ in pairs(db[group]) do
|
|
if type(k) ~= "string" or not k:match("__.*") then
|
|
tab[k] = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local rv = {}
|
|
for k, _ in pairs(tab) do
|
|
table.insert(rv, k)
|
|
end
|
|
|
|
return rv
|
|
end
|
|
|
|
function DB_how_many_are_used()
|
|
local count = 0
|
|
for k, v in pairs(cache) do
|
|
for k2, v2 in pairs(v) do
|
|
count = count + 1
|
|
end
|
|
end
|
|
print(count)
|
|
end
|
|
|
|
function DB_DumpItems()
|
|
local dt = {}
|
|
for k, v in pairs(freq_group) do
|
|
dt[string.format("%s/%s", freq_group[k], tostring(freq_id[k]))] = true
|
|
end
|
|
return dt
|
|
end
|