Module:BassaridEmployment: Difference between revisions
From MicrasWiki
Jump to navigationJump to search
NewZimiaGov (talk | contribs) No edit summary |
NewZimiaGov (talk | contribs) No edit summary |
||
| Line 1: | Line 1: | ||
-- Module:BassaridEmployment (Optimized, no feature removal) | |||
-- | |||
-- Employment report derived from company rosters inside: | |||
-- Module:AutoUpdateAgPrices | |||
-- Module:AutoUpdateManfPrices | |||
-- Module:AutoUpdateServPrices | |||
-- | |||
-- Factors: | |||
-- costs (price-module ratios), weather (BassaridiaForecast), market (BassaridMarketActivity), | |||
-- War League tempo (WarLeagueDivisionOpsBVR), Temple tempo (MissionaryDailyOpsBVR), | |||
-- optional Hatch Ministry tempo (HatchMinistryDailyOpsBVR if present). | |||
-- | |||
-- Auditable output: | |||
-- Shows distinct product counts per company and per-row multipliers for each factor. | |||
-- | -- | ||
-- | -- OPTIMIZATIONS (no output/features removed): | ||
-- | -- 1) Each price module is rendered ONCE per page render (breakdown), and we extract: | ||
-- | -- - roster + distinct products per company | ||
-- | -- - sector membership | ||
-- - | -- - average adjusted vs base (for cost ratio) | ||
-- | -- This replaces the previous double-render (breakdown + summary) per price module. | ||
-- 2) All requires are cached (pcall(require) once per dependency). | |||
-- 3) Fast splitting for "||" lines (no mw.text.split per row). | |||
-- 4) Output is still built with table buffers. | |||
-- | -- | ||
-- Usage: | -- Usage: | ||
-- {{#invoke:BassaridEmployment|generateTable}} | -- {{#invoke:BassaridEmployment|generateTable}} | ||
-- | -- |city=Vaeringheim | ||
-- | | -- |sector= (optional: Agricultural | Mining/Manufacturing | Services) | ||
-- | | -- |limit= (optional: numeric) | ||
-- | | -- |dashboard=yes/no | ||
--------------------------------------------------------- | local p = {} | ||
-------------------------------------------------------------------------------- | |||
-- UTIL | |||
-------------------------------------------------------------------------------- | |||
local function trim(s) | |||
s = tostring(s or "") | |||
return (s:gsub("^%s+", ""):gsub("%s+$", "")) | |||
end | |||
--------------------------------------------------------- | local function stripWiki(s) | ||
-- | s = tostring(s or "") | ||
-- | s = s:gsub("%{%b{}%}", "") -- templates | ||
--------------------------------------------------------- | s = s:gsub("%[%[[^%]|]+|([^%]]+)%]%]", "%1") -- piped links | ||
local function | s = s:gsub("%[%[([^%]]+)%]%]", "%1") -- plain links | ||
local startDate = os.time({ year = 1999, month = 8, day = 6 }) | s = s:gsub("'''''", ""):gsub("'''", ""):gsub("''", "") -- ital/bold | ||
s = s:gsub(" ", " ") | |||
return trim(s) | |||
end | |||
local function clamp(x, lo, hi) | |||
if x < lo then return lo end | |||
if x > hi then return hi end | |||
return x | |||
end | |||
local function hashFrac(s) | |||
local ok, h = pcall(function() return mw.hash.hashValue("md5", tostring(s or "")) end) | |||
if not ok or not h or #h < 8 then return 0.5 end | |||
local n = tonumber(h:sub(1, 8), 16) or 0 | |||
return (n % 1000000) / 1000000 | |||
end | |||
-------------------------------------------------------------------------------- | |||
-- SAFE REQUIRE (cached) | |||
-------------------------------------------------------------------------------- | |||
local _reqCache = {} | |||
local function safeRequire(name) | |||
if _reqCache[name] ~= nil then | |||
return _reqCache[name] | |||
end | |||
local ok, mod = pcall(require, name) | |||
if not ok then mod = false end | |||
_reqCache[name] = mod | |||
return mod | |||
end | |||
-------------------------------------------------------------------------------- | |||
-- DATE (PSSC) | |||
-------------------------------------------------------------------------------- | |||
local DAYS_IN_YEAR = 183 | |||
local function getCurrentDateInfo() | |||
local startDate = os.time({year = 1999, month = 8, day = 6}) | |||
local secondsInDay = 86400 | local secondsInDay = 86400 | ||
local | local now = os.time() | ||
local totalDays = math.floor((now - startDate) / secondsInDay) | |||
local yearFraction = totalDays / DAYS_IN_YEAR | |||
local psscYear = math.floor(yearFraction) | |||
local dayOfYear = math.floor((yearFraction - psscYear) * DAYS_IN_YEAR) + 1 | |||
local month, dayOfMonth | |||
if dayOfYear <= 61 then month, dayOfMonth = 1, dayOfYear | |||
elseif dayOfYear <= 122 then month, dayOfMonth = 2, dayOfYear - 61 | |||
else month, dayOfMonth = 3, dayOfYear - 122 end | |||
return { | |||
dateString = string.format("%d/%d/%d [[PSSC]]", dayOfMonth, month, psscYear), | |||
year = psscYear, | |||
dayOfYear = dayOfYear | |||
} | |||
end | |||
local | -------------------------------------------------------------------------------- | ||
if | -- FAST "||" SPLITTER FOR PRICE-MODULE DATA LINES | ||
-------------------------------------------------------------------------------- | |||
local function splitCellsByDoublePipeFast(line) | |||
line = trim(line):gsub("^|%s*", "") | |||
local cells = {} | |||
local i = 1 | |||
for part in line:gmatch("([^|][^|]*)%s*%|%|%s*") do | |||
cells[i] = trim(part) | |||
i = i + 1 | |||
end | |||
local tail = line:match("||%s*([^|].*)$") | |||
if tail then | |||
cells[i] = trim(tail) | |||
end | |||
return cells | |||
end | |||
-------------------------------------------------------------------------------- | |||
-- PRICE MODULE CACHE (render once; extract roster + product counts + cost ratio) | |||
-------------------------------------------------------------------------------- | |||
local priceCache = {} -- moduleName -> pack | |||
local function parseAverageAdjustedVsBase(text) | |||
local aNew, aBase = text:match("Average adjusted %(([%d%.]+)%) vs base %(([%d%.]+)%)") | |||
aNew, aBase = tonumber(aNew), tonumber(aBase) | |||
if not aNew or not aBase or aBase == 0 then return nil, nil end | |||
return aNew, aBase | |||
end | |||
local function extractFromPriceModule(modName, sectorLabel) | |||
if priceCache[modName] then return priceCache[modName] end | |||
local m = safeRequire(modName) | |||
if not m or type(m.generateTable) ~= "function" then | |||
local pack = { present = false, companies = {}, productCount = {}, ratio = 1.0, sector = sectorLabel } | |||
priceCache[modName] = pack | |||
return pack | |||
end | |||
local out = m.generateTable({ args = { mode = "breakdown", collapse = "no" } }) or "" | |||
local companies, seenCompany = {}, {} | |||
local productsSeenByCompany = {} | |||
for line in out:gmatch("[^\n]+") do | |||
line = trim(line) | |||
if line:match("^|%s*%d+/%d+/%d+%s*%[%[PSSC%]%]%s*||") then | |||
local cells = splitCellsByDoublePipeFast(line) | |||
local product = stripWiki(cells[2] or "") | |||
local company = stripWiki(cells[3] or "") | |||
if company ~= "" then | |||
if not seenCompany[company] then | |||
seenCompany[company] = true | |||
companies[#companies + 1] = { name = company, sector = sectorLabel } | |||
end | |||
if product ~= "" then | |||
local set = productsSeenByCompany[company] | |||
if not set then | |||
set = {} | |||
productsSeenByCompany[company] = set | |||
end | |||
set[product] = true | |||
end | |||
end | |||
end | |||
end | |||
local distinctCount = {} | |||
for company, set in pairs(productsSeenByCompany) do | |||
local n = 0 | |||
for _ in pairs(set) do n = n + 1 end | |||
distinctCount[company] = n | |||
end | |||
local aNew, aBase = parseAverageAdjustedVsBase(out) | |||
local ratio = 1.0 | |||
if aNew and aBase and aBase ~= 0 then ratio = aNew / aBase end | |||
local pack = { | |||
present = true, | |||
companies = companies, | |||
productCount = distinctCount, | |||
ratio = ratio, | |||
sector = sectorLabel | |||
} | |||
priceCache[modName] = pack | |||
return pack | |||
end | |||
local function buildCompanyRosterAndCounts() | |||
local roster = {} | |||
local counts = {} | |||
local seen = {} | |||
local ag = extractFromPriceModule("Module:AutoUpdateAgPrices", "Agricultural") | |||
local mf = extractFromPriceModule("Module:AutoUpdateManfPrices", "Mining/Manufacturing") | |||
local sv = extractFromPriceModule("Module:AutoUpdateServPrices", "Services") | |||
local function addPack(pack) | |||
for _, c in ipairs(pack.companies or {}) do | |||
if not seen[c.name] then | |||
seen[c.name] = true | |||
roster[#roster + 1] = c | |||
end | |||
counts[c.name] = (counts[c.name] or 0) + (pack.productCount[c.name] or 0) | |||
end | |||
end | end | ||
return | addPack(ag); addPack(mf); addPack(sv) | ||
return { | |||
roster = roster, | |||
productCounts = counts, | |||
modulePresence = { ag = ag.present, mf = mf.present, sv = sv.present }, | |||
pricePacks = { ag = ag, mf = mf, sv = sv } | |||
} | |||
end | end | ||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
-- | -- COST INDEX MULTIPLIER (sector-based) | ||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
local | local function sectorCostMultiplier(sec, costAg, costManf, costServ) | ||
local r = 1.0 | |||
if sec == "Agricultural" then r = costAg.ratio or 1.0 | |||
elseif sec == "Mining/Manufacturing" then r = costManf.ratio or 1.0 | |||
elseif sec == "Services" then r = costServ.ratio or 1.0 end | |||
return clamp(0.92 + (r - 1.0) * 0.20, 0.85, 1.12) | |||
end | |||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
-- | -- MARKET SENTIMENT | ||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
local | local function getMarketSentiment() | ||
local m = safeRequire("Module:BassaridMarketActivity") | |||
if not m or type(m.generateTable) ~= "function" then | |||
return { present = false, bias = 0.0, avgPct = 0.0 } | |||
end | |||
local out = m.generateTable({ args = {} }) or "" | |||
local sum, n, pos, neg = 0, 0, 0, 0 | |||
for pct in out:gmatch("([%+%-]?%d+%.?%d*)%%") do | |||
local v = tonumber(pct) | |||
if v then | |||
sum = sum + v | |||
n = n + 1 | |||
if v > 0 then pos = pos + 1 elseif v < 0 then neg = neg + 1 end | |||
end | |||
end | |||
local avg = (n > 0) and (sum / n) or 0.0 | |||
local bias = (n > 0) and ((pos - neg) / n) or 0.0 | |||
return { present = true, bias = bias, avgPct = avg } | |||
end | |||
local function marketMultiplier(market, sector) | |||
local b = clamp(market.bias or 0, -1, 1) | |||
if sector == "Services" then | |||
return clamp(1.0 + b * 0.03, 0.95, 1.05) | |||
elseif sector == "Mining/Manufacturing" then | |||
return clamp(1.0 + b * 0.02, 0.96, 1.04) | |||
else | |||
return clamp(1.0 + b * 0.01, 0.97, 1.03) | |||
end | |||
end | |||
local function | -------------------------------------------------------------------------------- | ||
-- WEATHER | |||
-------------------------------------------------------------------------------- | |||
local function getWeatherSignal(city, year, dayOfYear) | |||
local wx = safeRequire("Module:BassaridiaForecast") | |||
if not wx or type(wx.getOpsData) ~= "function" then | |||
return { present = false, level = 0, label = "Green", impacts = {}, condition = "" } | |||
end | |||
local op = wx.getOpsData(city, year, dayOfYear) | |||
if not op or not op.alert then | |||
return { present = true, level = 0, label = "Green", impacts = {}, condition = "" } | |||
end | end | ||
return | return { | ||
present = true, | |||
level = tonumber(op.alert.level) or 0, | |||
label = tostring(op.alert.label or "Green"), | |||
condition = tostring(op.condition or ""), | |||
impacts = op.impacts or {} | |||
} | |||
end | end | ||
local function | local function weatherMultiplier(wx, sector) | ||
local lvl = tonumber(wx.level or 0) or 0 | |||
local m = 1.0 | |||
if lvl == 1 then m = 0.98 | |||
elseif lvl == 2 then m = 0.93 | |||
elseif lvl >= 3 then m = 0.85 end | |||
local imp = wx.impacts or {} | |||
local g = tostring(imp.ground or "") | |||
local s = tostring(imp.sea or "") | |||
local a = tostring(imp.air or "") | |||
if sector == "Agricultural" then | |||
if g == "No-Go" then m = m * 0.75 | |||
elseif g == "Degraded" then m = m * 0.90 end | |||
elseif sector == "Mining/Manufacturing" then | |||
if g == "No-Go" then m = m * 0.78 | |||
elseif g == "Degraded" then m = m * 0.92 end | |||
elseif sector == "Services" then | |||
if s == "Closed" then m = m * 0.85 | |||
elseif s == "Degraded" then m = m * 0.93 end | |||
if a == "No-Go" then m = m * 0.92 end | |||
end | end | ||
return clamp(m, 0.65, 1.10) | |||
end | end | ||
local function | -------------------------------------------------------------------------------- | ||
if | -- WAR LEAGUE TEMPO | ||
local | -------------------------------------------------------------------------------- | ||
local | local function getWarTempo(di) | ||
return | local wl = safeRequire("Module:WarLeagueDivisionOpsBVR") | ||
if not wl or type(wl.makeTable) ~= "function" then | |||
return { present = false, score = 0, redRate = 0 } | |||
end | |||
local out = wl.makeTable({ args = { rows = 36, showlegend = "no", seed = (di.year * 1000 + di.dayOfYear) } }) or "" | |||
local rows, high, critical = 0, 0, 0 | |||
for u in out:gmatch("||%s*(LOW|MEDIUM|HIGH|CRITICAL)%s*||") do | |||
rows = rows + 1 | |||
if u == "HIGH" then high = high + 1 end | |||
if u == "CRITICAL" then critical = critical + 1 end | |||
end | |||
if rows == 0 then rows = 36 end | |||
local severity = (high * 1.0 + critical * 2.0) / rows | |||
return { present = true, score = severity, redRate = (high + critical) / rows } | |||
end | end | ||
local function warMultiplier(war, sector) | |||
local s = tonumber(war.score or 0) or 0 | |||
if sector == "Services" then | |||
return clamp(1.0 + (s * 0.08), 0.95, 1.18) | |||
elseif sector == "Mining/Manufacturing" then | |||
return clamp(1.0 + (s * 0.06), 0.95, 1.15) | |||
elseif sector == "Agricultural" then | |||
return clamp(1.0 - (s * 0.03), 0.88, 1.05) | |||
end | |||
return 1.0 | |||
end | |||
local | -------------------------------------------------------------------------------- | ||
local | -- TEMPLE TEMPO | ||
-------------------------------------------------------------------------------- | |||
local function getTempleTempo() | |||
local tb = safeRequire("Module:MissionaryDailyOpsBVR") | |||
if not tb or type(tb.makeTable) ~= "function" then | |||
return { present = false, redRate = 0 } | |||
end | |||
local out = tb.makeTable({ args = { region = "Core", includeThreat = "no", showEcon = "no", limit = 40, showlegend = "no" } }) or "" | |||
local red, n = 0, 0 | |||
for sev in out:gmatch("||%s*(Green|Yellow|Red)%s*$") do | |||
n = n + 1 | |||
if sev == "Red" then red = red + 1 end | |||
end | |||
if n == 0 then n = 40 end | |||
return { present = true, redRate = red / n } | |||
end | |||
local | local function templeMultiplier(temple, sector) | ||
local r = tonumber(temple.redRate or 0) or 0 | |||
if sector == "Services" then | |||
return clamp(1.0 + (r * 0.06), 0.98, 1.10) | |||
end | |||
return clamp(1.0 + (r * 0.02), 0.98, 1.06) | |||
end | |||
local | -------------------------------------------------------------------------------- | ||
if | -- OPTIONAL HATCH MINISTRY TEMPO | ||
-------------------------------------------------------------------------------- | |||
local function getHatchTempo(di) | |||
local hm = safeRequire("Module:HatchMinistryDailyOpsBVR") | |||
if not hm or type(hm.makeTable) ~= "function" then | |||
return { present = false, intensity = 0 } | |||
end | end | ||
local out = hm.makeTable({ args = { rows = 30, seed = (di.year * 1000 + di.dayOfYear) } }) or "" | |||
local c = 0 | |||
for _ in out:gmatch("[Ii]nterdict") do c = c + 1 end | |||
for _ in out:gmatch("[Ii]nspect") do c = c + 1 end | |||
for _ in out:gmatch("[Ss]eiz") do c = c + 1 end | |||
return { present = true, intensity = c } | |||
end | |||
local | local function hatchMultiplier(hatch, sector) | ||
if not hatch or not hatch.present then return 1.0 end | |||
local x = tonumber(hatch.intensity or 0) or 0 | |||
if sector == "Services" then | |||
return clamp(1.0 + (x * 0.002), 1.0, 1.12) | |||
else | |||
return clamp(1.0 - (x * 0.001), 0.90, 1.02) | |||
end | |||
end | |||
return | -------------------------------------------------------------------------------- | ||
-- BASE SHARES (uses distinct product counts as size proxy) | |||
-------------------------------------------------------------------------------- | |||
local function buildBaseShares(roster, productCounts) | |||
local sectorTarget = { Agricultural = 0.34, ["Mining/Manufacturing"] = 0.33, Services = 0.33 } | |||
local bySector = { Agricultural = {}, ["Mining/Manufacturing"] = {}, Services = {} } | |||
for _, c in ipairs(roster) do | |||
bySector[c.sector][#bySector[c.sector] + 1] = c | |||
end | |||
local shares = {} | |||
for sec, list in pairs(bySector) do | |||
local rawSum = 0 | |||
for _, c in ipairs(list) do | |||
local nprod = productCounts[c.name] or 1 | |||
local w = math.sqrt(math.max(1, nprod)) * (0.7 + hashFrac("w:" .. c.name) * 1.2) | |||
shares[c.name] = { share = 0, nprod = nprod, raw = w, sector = sec } | |||
rawSum = rawSum + w | |||
end | |||
local target = sectorTarget[sec] or 0 | |||
for _, c in ipairs(list) do | |||
local rec = shares[c.name] | |||
rec.share = (rawSum > 0) and (rec.raw / rawSum) * target or 0 | |||
end | |||
end | |||
return shares | |||
end | end | ||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
-- | -- MAIN | ||
--------------------------------------------------------- | -------------------------------------------------------------------------------- | ||
function p.generateTable(frame) | function p.generateTable(frame) | ||
frame | local args = (frame and frame.args) or {} | ||
local args = ( | local di = getCurrentDateInfo() | ||
local | local city = tostring(args.city or "Vaeringheim") | ||
local sectorFilter = trim(tostring(args.sector or "")) | |||
local limit = tonumber(args.limit or "") | |||
local showDashboard = tostring(args.dashboard or "yes"):lower() ~= "no" | |||
math.randomseed(di.year * 1000 + di.dayOfYear) | |||
local rosterPack = buildCompanyRosterAndCounts() | |||
local roster = rosterPack.roster | |||
local productCounts = rosterPack.productCounts | |||
if #roster == 0 then | |||
return "''BassaridEmployment error: could not read company rosters from the three price modules.''" | |||
end | |||
local | local shares = buildBaseShares(roster, productCounts) | ||
-- cost ratios (extracted from price-module breakdown output) | |||
local costAg = rosterPack.pricePacks.ag | |||
local costManf = rosterPack.pricePacks.mf | |||
local costServ = rosterPack.pricePacks.sv | |||
local | local market = getMarketSentiment() | ||
local wx = getWeatherSignal(city, di.year, di.dayOfYear) | |||
local war = getWarTempo(di) | |||
local temple = getTempleTempo() | |||
local hatch = getHatchTempo(di) | |||
local | local population = 94160000 | ||
local | local baseU = 0.04 | ||
local u = baseU | |||
u = u - clamp((market.bias or 0) * 0.01, -0.01, 0.01) | |||
u = u + clamp((wx.level or 0) * 0.005, 0, 0.02) | |||
u = clamp(u, 0.02, 0.08) | |||
local employedPopulation = math.floor(population * (1 - u)) | |||
local | local function combinedMultiplier(sec) | ||
local mCost = sectorCostMultiplier(sec, costAg, costManf, costServ) | |||
local mWx = weatherMultiplier(wx, sec) | |||
local mWar = warMultiplier(war, sec) | |||
local mTemple = templeMultiplier(temple, sec) | |||
local mHatch = hatchMultiplier(hatch, sec) | |||
local mMkt = marketMultiplier(market, sec) | |||
return clamp(mCost * mWx * mWar * mTemple * mHatch * mMkt, 0.65, 1.25), | |||
mCost, mWx, mWar, mTemple, mHatch, mMkt | |||
end | |||
local out = {} | local out = {} | ||
if showDashboard then | |||
out[#out + 1] = "{| class=\"wikitable\" style=\"width:100%;\"" | |||
out[#out + 1] = "! colspan=\"4\" | Employment factor audit — " .. di.dateString | |||
out[#out + 1] = "|-" | |||
out[#out + 1] = string.format("| '''Rosters present''' || Ag=%s; Manf=%s; Serv=%s || '''Weather''' || %s (%s)", | |||
tostring(rosterPack.modulePresence.ag), | |||
tostring(rosterPack.modulePresence.mf), | |||
tostring(rosterPack.modulePresence.sv), | |||
(wx.label or "Green"), (wx.condition or "")) | |||
out[#out + 1] = "|-" | |||
out[#out + 1] = string.format("| '''Costs present''' || Ag=%s (%.3f); Manf=%s (%.3f); Serv=%s (%.3f) || '''Market present''' || %s (bias %.2f)", | |||
tostring(costAg.present), (costAg.ratio or 1.0), | |||
tostring(costManf.present), (costManf.ratio or 1.0), | |||
tostring(costServ.present), (costServ.ratio or 1.0), | |||
tostring(market.present), (market.bias or 0)) | |||
out[#out + 1] = "|-" | |||
out[#out + 1] = string.format("| '''War present''' || %s (red-rate %.2f) || '''Temple present''' || %s (red-rate %.2f)", | |||
tostring(war.present), (war.redRate or 0), | |||
tostring(temple.present), (temple.redRate or 0)) | |||
out[#out + 1] = "|-" | |||
out[#out + 1] = string.format("| '''Hatch present''' || %s (intensity %d) || '''Modeled unemployment''' || %.2f%%", | |||
tostring(hatch.present), (hatch.intensity or 0), u * 100) | |||
out[#out + 1] = "|}" | |||
out[#out + 1] = "" | |||
end | |||
out[#out + 1] = '<div style="overflow-x:auto;">' | |||
out[#out + 1] = "{| class=\"wikitable sortable\"" | |||
out[#out + 1] = "! Date !! Sector !! Company !! Products (distinct) !! Base Share % !! Prev Emp. !! Curr Emp. !! Δ !! mCost !! mWx !! mWar !! mTemple !! mHatch !! mMkt" | |||
local | local n = 0 | ||
if | for _, c in ipairs(roster) do | ||
local sec = c.sector | |||
if sectorFilter == "" or sec == sectorFilter then | |||
local rec = shares[c.name] | |||
local share = (rec and rec.share) or 0 | |||
local nprod = (rec and rec.nprod) or (productCounts[c.name] or 0) | |||
local prev = math.max(1, math.floor(employedPopulation * share)) | |||
local mAll, mCost, mWx, mWar, mTemple, mHatch, mMkt = combinedMultiplier(sec) | |||
local jitter = (hashFrac(string.format("jit:%s:%d:%d", c.name, di.year, di.dayOfYear)) - 0.5) * 0.18 | |||
local curr = math.max(1, math.floor(prev * mAll * (1.0 + jitter))) | |||
local deltaSym = "•" | |||
if curr > prev then deltaSym = "↑" | |||
elseif curr < prev then deltaSym = "↓" end | |||
local rowStyle | |||
if curr > prev then rowStyle = ' style="background-color:lightblue;"' | |||
elseif curr == prev then rowStyle = ' style="background-color:lightgreen;"' | |||
else rowStyle = ' style="background-color:#ffcccb;"' end | |||
out[#out + 1] = string.format( | |||
"|-%s\n| %s || %s || %s || %d || %.3f%% || %d || %d || %s || %.2f || %.2f || %.2f || %.2f || %.2f || %.2f", | |||
rowStyle, | |||
di.dateString, | |||
sec, | |||
c.name, | |||
nprod, | |||
share * 100, | |||
prev, | |||
curr, | |||
deltaSym, | |||
mCost, mWx, mWar, mTemple, mHatch, mMkt | |||
) | |||
n = n + 1 | |||
if limit and n >= limit then break end | |||
end | |||
end | end | ||
out[#out + 1] = "|}" | out[#out + 1] = "|}" | ||
out[#out + 1] = "</div>" | |||
return table.concat(out) | return table.concat(out, "\n") | ||
end | end | ||
return p | return p | ||
Revision as of 01:28, 20 January 2026
Documentation for this module may be created at Module:BassaridEmployment/doc
-- Module:BassaridEmployment (Optimized, no feature removal)
--
-- Employment report derived from company rosters inside:
-- Module:AutoUpdateAgPrices
-- Module:AutoUpdateManfPrices
-- Module:AutoUpdateServPrices
--
-- Factors:
-- costs (price-module ratios), weather (BassaridiaForecast), market (BassaridMarketActivity),
-- War League tempo (WarLeagueDivisionOpsBVR), Temple tempo (MissionaryDailyOpsBVR),
-- optional Hatch Ministry tempo (HatchMinistryDailyOpsBVR if present).
--
-- Auditable output:
-- Shows distinct product counts per company and per-row multipliers for each factor.
--
-- OPTIMIZATIONS (no output/features removed):
-- 1) Each price module is rendered ONCE per page render (breakdown), and we extract:
-- - roster + distinct products per company
-- - sector membership
-- - average adjusted vs base (for cost ratio)
-- This replaces the previous double-render (breakdown + summary) per price module.
-- 2) All requires are cached (pcall(require) once per dependency).
-- 3) Fast splitting for "||" lines (no mw.text.split per row).
-- 4) Output is still built with table buffers.
--
-- Usage:
-- {{#invoke:BassaridEmployment|generateTable}}
-- |city=Vaeringheim
-- |sector= (optional: Agricultural | Mining/Manufacturing | Services)
-- |limit= (optional: numeric)
-- |dashboard=yes/no
local p = {}
--------------------------------------------------------------------------------
-- UTIL
--------------------------------------------------------------------------------
local function trim(s)
s = tostring(s or "")
return (s:gsub("^%s+", ""):gsub("%s+$", ""))
end
local function stripWiki(s)
s = tostring(s or "")
s = s:gsub("%{%b{}%}", "") -- templates
s = s:gsub("%[%[[^%]|]+|([^%]]+)%]%]", "%1") -- piped links
s = s:gsub("%[%[([^%]]+)%]%]", "%1") -- plain links
s = s:gsub("'''''", ""):gsub("'''", ""):gsub("''", "") -- ital/bold
s = s:gsub(" ", " ")
return trim(s)
end
local function clamp(x, lo, hi)
if x < lo then return lo end
if x > hi then return hi end
return x
end
local function hashFrac(s)
local ok, h = pcall(function() return mw.hash.hashValue("md5", tostring(s or "")) end)
if not ok or not h or #h < 8 then return 0.5 end
local n = tonumber(h:sub(1, 8), 16) or 0
return (n % 1000000) / 1000000
end
--------------------------------------------------------------------------------
-- SAFE REQUIRE (cached)
--------------------------------------------------------------------------------
local _reqCache = {}
local function safeRequire(name)
if _reqCache[name] ~= nil then
return _reqCache[name]
end
local ok, mod = pcall(require, name)
if not ok then mod = false end
_reqCache[name] = mod
return mod
end
--------------------------------------------------------------------------------
-- DATE (PSSC)
--------------------------------------------------------------------------------
local DAYS_IN_YEAR = 183
local function getCurrentDateInfo()
local startDate = os.time({year = 1999, month = 8, day = 6})
local secondsInDay = 86400
local now = os.time()
local totalDays = math.floor((now - startDate) / secondsInDay)
local yearFraction = totalDays / DAYS_IN_YEAR
local psscYear = math.floor(yearFraction)
local dayOfYear = math.floor((yearFraction - psscYear) * DAYS_IN_YEAR) + 1
local month, dayOfMonth
if dayOfYear <= 61 then month, dayOfMonth = 1, dayOfYear
elseif dayOfYear <= 122 then month, dayOfMonth = 2, dayOfYear - 61
else month, dayOfMonth = 3, dayOfYear - 122 end
return {
dateString = string.format("%d/%d/%d [[PSSC]]", dayOfMonth, month, psscYear),
year = psscYear,
dayOfYear = dayOfYear
}
end
--------------------------------------------------------------------------------
-- FAST "||" SPLITTER FOR PRICE-MODULE DATA LINES
--------------------------------------------------------------------------------
local function splitCellsByDoublePipeFast(line)
line = trim(line):gsub("^|%s*", "")
local cells = {}
local i = 1
for part in line:gmatch("([^|][^|]*)%s*%|%|%s*") do
cells[i] = trim(part)
i = i + 1
end
local tail = line:match("||%s*([^|].*)$")
if tail then
cells[i] = trim(tail)
end
return cells
end
--------------------------------------------------------------------------------
-- PRICE MODULE CACHE (render once; extract roster + product counts + cost ratio)
--------------------------------------------------------------------------------
local priceCache = {} -- moduleName -> pack
local function parseAverageAdjustedVsBase(text)
local aNew, aBase = text:match("Average adjusted %(([%d%.]+)%) vs base %(([%d%.]+)%)")
aNew, aBase = tonumber(aNew), tonumber(aBase)
if not aNew or not aBase or aBase == 0 then return nil, nil end
return aNew, aBase
end
local function extractFromPriceModule(modName, sectorLabel)
if priceCache[modName] then return priceCache[modName] end
local m = safeRequire(modName)
if not m or type(m.generateTable) ~= "function" then
local pack = { present = false, companies = {}, productCount = {}, ratio = 1.0, sector = sectorLabel }
priceCache[modName] = pack
return pack
end
local out = m.generateTable({ args = { mode = "breakdown", collapse = "no" } }) or ""
local companies, seenCompany = {}, {}
local productsSeenByCompany = {}
for line in out:gmatch("[^\n]+") do
line = trim(line)
if line:match("^|%s*%d+/%d+/%d+%s*%[%[PSSC%]%]%s*||") then
local cells = splitCellsByDoublePipeFast(line)
local product = stripWiki(cells[2] or "")
local company = stripWiki(cells[3] or "")
if company ~= "" then
if not seenCompany[company] then
seenCompany[company] = true
companies[#companies + 1] = { name = company, sector = sectorLabel }
end
if product ~= "" then
local set = productsSeenByCompany[company]
if not set then
set = {}
productsSeenByCompany[company] = set
end
set[product] = true
end
end
end
end
local distinctCount = {}
for company, set in pairs(productsSeenByCompany) do
local n = 0
for _ in pairs(set) do n = n + 1 end
distinctCount[company] = n
end
local aNew, aBase = parseAverageAdjustedVsBase(out)
local ratio = 1.0
if aNew and aBase and aBase ~= 0 then ratio = aNew / aBase end
local pack = {
present = true,
companies = companies,
productCount = distinctCount,
ratio = ratio,
sector = sectorLabel
}
priceCache[modName] = pack
return pack
end
local function buildCompanyRosterAndCounts()
local roster = {}
local counts = {}
local seen = {}
local ag = extractFromPriceModule("Module:AutoUpdateAgPrices", "Agricultural")
local mf = extractFromPriceModule("Module:AutoUpdateManfPrices", "Mining/Manufacturing")
local sv = extractFromPriceModule("Module:AutoUpdateServPrices", "Services")
local function addPack(pack)
for _, c in ipairs(pack.companies or {}) do
if not seen[c.name] then
seen[c.name] = true
roster[#roster + 1] = c
end
counts[c.name] = (counts[c.name] or 0) + (pack.productCount[c.name] or 0)
end
end
addPack(ag); addPack(mf); addPack(sv)
return {
roster = roster,
productCounts = counts,
modulePresence = { ag = ag.present, mf = mf.present, sv = sv.present },
pricePacks = { ag = ag, mf = mf, sv = sv }
}
end
--------------------------------------------------------------------------------
-- COST INDEX MULTIPLIER (sector-based)
--------------------------------------------------------------------------------
local function sectorCostMultiplier(sec, costAg, costManf, costServ)
local r = 1.0
if sec == "Agricultural" then r = costAg.ratio or 1.0
elseif sec == "Mining/Manufacturing" then r = costManf.ratio or 1.0
elseif sec == "Services" then r = costServ.ratio or 1.0 end
return clamp(0.92 + (r - 1.0) * 0.20, 0.85, 1.12)
end
--------------------------------------------------------------------------------
-- MARKET SENTIMENT
--------------------------------------------------------------------------------
local function getMarketSentiment()
local m = safeRequire("Module:BassaridMarketActivity")
if not m or type(m.generateTable) ~= "function" then
return { present = false, bias = 0.0, avgPct = 0.0 }
end
local out = m.generateTable({ args = {} }) or ""
local sum, n, pos, neg = 0, 0, 0, 0
for pct in out:gmatch("([%+%-]?%d+%.?%d*)%%") do
local v = tonumber(pct)
if v then
sum = sum + v
n = n + 1
if v > 0 then pos = pos + 1 elseif v < 0 then neg = neg + 1 end
end
end
local avg = (n > 0) and (sum / n) or 0.0
local bias = (n > 0) and ((pos - neg) / n) or 0.0
return { present = true, bias = bias, avgPct = avg }
end
local function marketMultiplier(market, sector)
local b = clamp(market.bias or 0, -1, 1)
if sector == "Services" then
return clamp(1.0 + b * 0.03, 0.95, 1.05)
elseif sector == "Mining/Manufacturing" then
return clamp(1.0 + b * 0.02, 0.96, 1.04)
else
return clamp(1.0 + b * 0.01, 0.97, 1.03)
end
end
--------------------------------------------------------------------------------
-- WEATHER
--------------------------------------------------------------------------------
local function getWeatherSignal(city, year, dayOfYear)
local wx = safeRequire("Module:BassaridiaForecast")
if not wx or type(wx.getOpsData) ~= "function" then
return { present = false, level = 0, label = "Green", impacts = {}, condition = "" }
end
local op = wx.getOpsData(city, year, dayOfYear)
if not op or not op.alert then
return { present = true, level = 0, label = "Green", impacts = {}, condition = "" }
end
return {
present = true,
level = tonumber(op.alert.level) or 0,
label = tostring(op.alert.label or "Green"),
condition = tostring(op.condition or ""),
impacts = op.impacts or {}
}
end
local function weatherMultiplier(wx, sector)
local lvl = tonumber(wx.level or 0) or 0
local m = 1.0
if lvl == 1 then m = 0.98
elseif lvl == 2 then m = 0.93
elseif lvl >= 3 then m = 0.85 end
local imp = wx.impacts or {}
local g = tostring(imp.ground or "")
local s = tostring(imp.sea or "")
local a = tostring(imp.air or "")
if sector == "Agricultural" then
if g == "No-Go" then m = m * 0.75
elseif g == "Degraded" then m = m * 0.90 end
elseif sector == "Mining/Manufacturing" then
if g == "No-Go" then m = m * 0.78
elseif g == "Degraded" then m = m * 0.92 end
elseif sector == "Services" then
if s == "Closed" then m = m * 0.85
elseif s == "Degraded" then m = m * 0.93 end
if a == "No-Go" then m = m * 0.92 end
end
return clamp(m, 0.65, 1.10)
end
--------------------------------------------------------------------------------
-- WAR LEAGUE TEMPO
--------------------------------------------------------------------------------
local function getWarTempo(di)
local wl = safeRequire("Module:WarLeagueDivisionOpsBVR")
if not wl or type(wl.makeTable) ~= "function" then
return { present = false, score = 0, redRate = 0 }
end
local out = wl.makeTable({ args = { rows = 36, showlegend = "no", seed = (di.year * 1000 + di.dayOfYear) } }) or ""
local rows, high, critical = 0, 0, 0
for u in out:gmatch("||%s*(LOW|MEDIUM|HIGH|CRITICAL)%s*||") do
rows = rows + 1
if u == "HIGH" then high = high + 1 end
if u == "CRITICAL" then critical = critical + 1 end
end
if rows == 0 then rows = 36 end
local severity = (high * 1.0 + critical * 2.0) / rows
return { present = true, score = severity, redRate = (high + critical) / rows }
end
local function warMultiplier(war, sector)
local s = tonumber(war.score or 0) or 0
if sector == "Services" then
return clamp(1.0 + (s * 0.08), 0.95, 1.18)
elseif sector == "Mining/Manufacturing" then
return clamp(1.0 + (s * 0.06), 0.95, 1.15)
elseif sector == "Agricultural" then
return clamp(1.0 - (s * 0.03), 0.88, 1.05)
end
return 1.0
end
--------------------------------------------------------------------------------
-- TEMPLE TEMPO
--------------------------------------------------------------------------------
local function getTempleTempo()
local tb = safeRequire("Module:MissionaryDailyOpsBVR")
if not tb or type(tb.makeTable) ~= "function" then
return { present = false, redRate = 0 }
end
local out = tb.makeTable({ args = { region = "Core", includeThreat = "no", showEcon = "no", limit = 40, showlegend = "no" } }) or ""
local red, n = 0, 0
for sev in out:gmatch("||%s*(Green|Yellow|Red)%s*$") do
n = n + 1
if sev == "Red" then red = red + 1 end
end
if n == 0 then n = 40 end
return { present = true, redRate = red / n }
end
local function templeMultiplier(temple, sector)
local r = tonumber(temple.redRate or 0) or 0
if sector == "Services" then
return clamp(1.0 + (r * 0.06), 0.98, 1.10)
end
return clamp(1.0 + (r * 0.02), 0.98, 1.06)
end
--------------------------------------------------------------------------------
-- OPTIONAL HATCH MINISTRY TEMPO
--------------------------------------------------------------------------------
local function getHatchTempo(di)
local hm = safeRequire("Module:HatchMinistryDailyOpsBVR")
if not hm or type(hm.makeTable) ~= "function" then
return { present = false, intensity = 0 }
end
local out = hm.makeTable({ args = { rows = 30, seed = (di.year * 1000 + di.dayOfYear) } }) or ""
local c = 0
for _ in out:gmatch("[Ii]nterdict") do c = c + 1 end
for _ in out:gmatch("[Ii]nspect") do c = c + 1 end
for _ in out:gmatch("[Ss]eiz") do c = c + 1 end
return { present = true, intensity = c }
end
local function hatchMultiplier(hatch, sector)
if not hatch or not hatch.present then return 1.0 end
local x = tonumber(hatch.intensity or 0) or 0
if sector == "Services" then
return clamp(1.0 + (x * 0.002), 1.0, 1.12)
else
return clamp(1.0 - (x * 0.001), 0.90, 1.02)
end
end
--------------------------------------------------------------------------------
-- BASE SHARES (uses distinct product counts as size proxy)
--------------------------------------------------------------------------------
local function buildBaseShares(roster, productCounts)
local sectorTarget = { Agricultural = 0.34, ["Mining/Manufacturing"] = 0.33, Services = 0.33 }
local bySector = { Agricultural = {}, ["Mining/Manufacturing"] = {}, Services = {} }
for _, c in ipairs(roster) do
bySector[c.sector][#bySector[c.sector] + 1] = c
end
local shares = {}
for sec, list in pairs(bySector) do
local rawSum = 0
for _, c in ipairs(list) do
local nprod = productCounts[c.name] or 1
local w = math.sqrt(math.max(1, nprod)) * (0.7 + hashFrac("w:" .. c.name) * 1.2)
shares[c.name] = { share = 0, nprod = nprod, raw = w, sector = sec }
rawSum = rawSum + w
end
local target = sectorTarget[sec] or 0
for _, c in ipairs(list) do
local rec = shares[c.name]
rec.share = (rawSum > 0) and (rec.raw / rawSum) * target or 0
end
end
return shares
end
--------------------------------------------------------------------------------
-- MAIN
--------------------------------------------------------------------------------
function p.generateTable(frame)
local args = (frame and frame.args) or {}
local di = getCurrentDateInfo()
local city = tostring(args.city or "Vaeringheim")
local sectorFilter = trim(tostring(args.sector or ""))
local limit = tonumber(args.limit or "")
local showDashboard = tostring(args.dashboard or "yes"):lower() ~= "no"
math.randomseed(di.year * 1000 + di.dayOfYear)
local rosterPack = buildCompanyRosterAndCounts()
local roster = rosterPack.roster
local productCounts = rosterPack.productCounts
if #roster == 0 then
return "''BassaridEmployment error: could not read company rosters from the three price modules.''"
end
local shares = buildBaseShares(roster, productCounts)
-- cost ratios (extracted from price-module breakdown output)
local costAg = rosterPack.pricePacks.ag
local costManf = rosterPack.pricePacks.mf
local costServ = rosterPack.pricePacks.sv
local market = getMarketSentiment()
local wx = getWeatherSignal(city, di.year, di.dayOfYear)
local war = getWarTempo(di)
local temple = getTempleTempo()
local hatch = getHatchTempo(di)
local population = 94160000
local baseU = 0.04
local u = baseU
u = u - clamp((market.bias or 0) * 0.01, -0.01, 0.01)
u = u + clamp((wx.level or 0) * 0.005, 0, 0.02)
u = clamp(u, 0.02, 0.08)
local employedPopulation = math.floor(population * (1 - u))
local function combinedMultiplier(sec)
local mCost = sectorCostMultiplier(sec, costAg, costManf, costServ)
local mWx = weatherMultiplier(wx, sec)
local mWar = warMultiplier(war, sec)
local mTemple = templeMultiplier(temple, sec)
local mHatch = hatchMultiplier(hatch, sec)
local mMkt = marketMultiplier(market, sec)
return clamp(mCost * mWx * mWar * mTemple * mHatch * mMkt, 0.65, 1.25),
mCost, mWx, mWar, mTemple, mHatch, mMkt
end
local out = {}
if showDashboard then
out[#out + 1] = "{| class=\"wikitable\" style=\"width:100%;\""
out[#out + 1] = "! colspan=\"4\" | Employment factor audit — " .. di.dateString
out[#out + 1] = "|-"
out[#out + 1] = string.format("| '''Rosters present''' || Ag=%s; Manf=%s; Serv=%s || '''Weather''' || %s (%s)",
tostring(rosterPack.modulePresence.ag),
tostring(rosterPack.modulePresence.mf),
tostring(rosterPack.modulePresence.sv),
(wx.label or "Green"), (wx.condition or ""))
out[#out + 1] = "|-"
out[#out + 1] = string.format("| '''Costs present''' || Ag=%s (%.3f); Manf=%s (%.3f); Serv=%s (%.3f) || '''Market present''' || %s (bias %.2f)",
tostring(costAg.present), (costAg.ratio or 1.0),
tostring(costManf.present), (costManf.ratio or 1.0),
tostring(costServ.present), (costServ.ratio or 1.0),
tostring(market.present), (market.bias or 0))
out[#out + 1] = "|-"
out[#out + 1] = string.format("| '''War present''' || %s (red-rate %.2f) || '''Temple present''' || %s (red-rate %.2f)",
tostring(war.present), (war.redRate or 0),
tostring(temple.present), (temple.redRate or 0))
out[#out + 1] = "|-"
out[#out + 1] = string.format("| '''Hatch present''' || %s (intensity %d) || '''Modeled unemployment''' || %.2f%%",
tostring(hatch.present), (hatch.intensity or 0), u * 100)
out[#out + 1] = "|}"
out[#out + 1] = ""
end
out[#out + 1] = '<div style="overflow-x:auto;">'
out[#out + 1] = "{| class=\"wikitable sortable\""
out[#out + 1] = "! Date !! Sector !! Company !! Products (distinct) !! Base Share % !! Prev Emp. !! Curr Emp. !! Δ !! mCost !! mWx !! mWar !! mTemple !! mHatch !! mMkt"
local n = 0
for _, c in ipairs(roster) do
local sec = c.sector
if sectorFilter == "" or sec == sectorFilter then
local rec = shares[c.name]
local share = (rec and rec.share) or 0
local nprod = (rec and rec.nprod) or (productCounts[c.name] or 0)
local prev = math.max(1, math.floor(employedPopulation * share))
local mAll, mCost, mWx, mWar, mTemple, mHatch, mMkt = combinedMultiplier(sec)
local jitter = (hashFrac(string.format("jit:%s:%d:%d", c.name, di.year, di.dayOfYear)) - 0.5) * 0.18
local curr = math.max(1, math.floor(prev * mAll * (1.0 + jitter)))
local deltaSym = "•"
if curr > prev then deltaSym = "↑"
elseif curr < prev then deltaSym = "↓" end
local rowStyle
if curr > prev then rowStyle = ' style="background-color:lightblue;"'
elseif curr == prev then rowStyle = ' style="background-color:lightgreen;"'
else rowStyle = ' style="background-color:#ffcccb;"' end
out[#out + 1] = string.format(
"|-%s\n| %s || %s || %s || %d || %.3f%% || %d || %d || %s || %.2f || %.2f || %.2f || %.2f || %.2f || %.2f",
rowStyle,
di.dateString,
sec,
c.name,
nprod,
share * 100,
prev,
curr,
deltaSym,
mCost, mWx, mWar, mTemple, mHatch, mMkt
)
n = n + 1
if limit and n >= limit then break end
end
end
out[#out + 1] = "|}"
out[#out + 1] = "</div>"
return table.concat(out, "\n")
end
return p