Module:BassaridiaForecast
From MicrasWiki
Jump to navigationJump to search
Documentation for this module may be created at Module:BassaridiaForecast/doc
---------------------------------------------------------
-- Module:BassaridiaForecast (FULL CITY COVERAGE + CITY FLAGS)
--
-- Updates embedded:
-- • Includes EVERY city on the canonical list (54) from List_of_cities_in_Bassaridia_Vaeringheim,
-- plus two climate-table-only Caledonian entries (Skøda, Krlsgorod) for completeness.
-- • Adds a City Flag icon in the City column.
-- • Flag standard: if the city flag file can't be found, show the Imperial Trade Union flag.
-- • Deterministic forecast per (city, year, day) so other modules can read the same signal.
-- • Exposes getOpsData(city, year, dayOfYear) for War League / Hatch / Missionary modules.
--
-- Usage:
-- {{#invoke:BassaridiaForecast|weatherForecast}}
-- {{#invoke:BassaridiaForecast|weatherForCity|city=Vaeringheim}}
-- {{#invoke:BassaridiaForecast|opsAlert|city=Vaeringheim}}
-- {{#invoke:BassaridiaForecast|starsForTonight}}
--
---------------------------------------------------------
local p = {}
---------------------------------------------------------
-- 0) Calendar integration (Module:BassaridianCalendar)
---------------------------------------------------------
local calOk, cal = pcall(require, "Module:BassaridianCalendar")
local DAYS_IN_YEAR = 183
local function getCurrentDateInfo_fallback()
local startDate = os.time({year=1999, month=8, day=6})
local secondsInDay = 86400
local currentTime = os.time()
local totalDays = math.floor((currentTime - startDate) / secondsInDay)
local psscYear = math.floor(totalDays / DAYS_IN_YEAR)
local dayOfYear = (totalDays % DAYS_IN_YEAR) + 1
return { psscYear = psscYear, dayOfYear = dayOfYear }
end
local function parseCalendarString(s)
s = tostring(s or "")
local day, year = s:match("^(%d+)%s*,.-,%s*(%d+)%s*PSSC")
if day and year then return tonumber(year), tonumber(day) end
year = s:match("(%d+)%s*PSSC")
day = s:match("^(%d+)")
if year and day then return tonumber(year), tonumber(day) end
return nil, nil
end
local function getDateInfo(args)
args = args or {}
local yy = tonumber(args.year)
local dd = tonumber(args.day)
if yy and dd and dd >= 1 and dd <= DAYS_IN_YEAR then
return { year = yy, dayOfYear = dd, source = "args" }
end
if calOk and cal and type(cal.getCurrentDate) == "function" then
local raw = cal.getCurrentDate()
local y, d = parseCalendarString(raw)
if y and d and d >= 1 and d <= DAYS_IN_YEAR then
return { year = y, dayOfYear = d, source = "calendar", raw = raw }
end
end
local fb = getCurrentDateInfo_fallback()
return { year = fb.psscYear, dayOfYear = fb.dayOfYear, source = "fallback" }
end
---------------------------------------------------------
-- 1) Season helper
---------------------------------------------------------
local function getSeasonName(dayOfYear)
if dayOfYear <= 61 then return "Atosiel"
elseif dayOfYear <= 122 then return "Thalassiel"
else return "Opsitheiel" end
end
---------------------------------------------------------
-- 2) Deterministic RNG
---------------------------------------------------------
local function hash31(str)
local h = 0
str = tostring(str or "")
for i = 1, #str do
h = (h * 131 + str:byte(i)) % 2147483647
end
return h
end
local function lcg(seed)
local s = seed % 2147483647
if s <= 0 then s = s + 2147483646 end
return function()
s = (1103515245 * s + 12345) % 2147483647
return s
end
end
local function rand01(nextInt) return (nextInt() % 1000000) / 1000000 end
local function randInt(nextInt, a, b)
a, b = tonumber(a) or 0, tonumber(b) or 0
if b < a then a, b = b, a end
return a + (nextInt() % (b - a + 1))
end
local function pickFromList(nextInt, list)
if not list or #list == 0 then return nil end
return list[(nextInt() % #list) + 1]
end
---------------------------------------------------------
-- 3) City flag logic (fallback to ITU flag if missing)
---------------------------------------------------------
local ITU_FLAG = "Imperial Trade Union flag.png"
local fileExistsCache = {}
local function fileExists(fileName)
fileName = tostring(fileName or "")
if fileName == "" then return false end
if fileExistsCache[fileName] ~= nil then return fileExistsCache[fileName] end
local t = mw.title.new("File:" .. fileName)
local ok = (t and t.exists) or false
fileExistsCache[fileName] = ok
return ok
end
local function normalizeForFlag(name)
-- Mirrors the lightweight normalization used in your other modules:
-- remove spaces/hyphens/’ and normalize common accented Latin chars.
name = tostring(name or "")
name = name:gsub("[%s%-’]", "")
name = name:gsub("[ÁáÀàÂâÄäÃãÅåĀā]", "A")
name = name:gsub("[ÉéÈèÊêËëĒē]", "E")
name = name:gsub("[ÍíÌìÎîÏïĪī]", "I")
name = name:gsub("[ÓóÒòÔôÖöÕõØøŌō]", "O")
name = name:gsub("[ÚúÙùÛûÜüŪū]", "U")
name = name:gsub("[ÝýŸÿ]", "Y")
name = name:gsub("[Ææ]", "AE")
return name
end
local cityFlagOverrides = {
["Skýrophos"] = "SkyrophosFlag.png",
["Slevik"] = "SlevikFlag.png.png",
["Sårensby"] = "SårensbyFlag.png",
["Odiferia"] = "OdiferiaFlag.png",
}
local cityFlagCache = {}
local function cityFlagMarkup(cityName, px)
px = tonumber(px) or 20
local key = tostring(cityName or "") .. "|" .. tostring(px)
if cityFlagCache[key] then return cityFlagCache[key] end
local candidate = cityFlagOverrides[cityName] or (normalizeForFlag(cityName) .. "Flag.png")
local file = fileExists(candidate) and candidate or ITU_FLAG
local mk = string.format("[[File:%s|%dpx]]", file, px)
cityFlagCache[key] = mk
return mk
end
local function cityLinkMarkup(cityName)
-- For canonical cities: link to the list-of-cities anchors.
-- For the two extra climate-table-only cities, link to their own page (if it exists) without anchor assumptions.
if cityName == "Skøda" or cityName == "Krlsgorod" then
return string.format("[[%s]]", cityName)
end
return string.format("[[List_of_cities_in_Bassaridia_Vaeringheim#%s|%s]]", cityName, cityName)
end
---------------------------------------------------------
-- 4) Weather helpers
---------------------------------------------------------
local function cToF(c)
if type(c) == "number" then return math.floor(c * 9/5 + 32 + 0.5) end
return c
end
local function conditionFromText(t)
t = (t or ""):lower()
if t:find("blizzard") then return "Blizzard" end
if t:find("snow") or t:find("sleet") or t:find("flurr") or t:find("ice") then return "Snow" end
if t:find("thunder") or t:find("severe") or t:find("downpour") or t:find("storm") then return "Storm" end
if t:find("rain") or t:find("drizzle") or t:find("shower") then return "Rain" end
if t:find("fog") or t:find("mist") or t:find("low visibility") then return "Fog" end
if t:find("dust") or t:find("sandstorm") or t:find("blowing sand") then return "Dust" end
if t:find("clear") or t:find("spotless") or t:find("sunny") then return "Clear" end
if t:find("overcast") or t:find("cloud") or t:find("gloom") or t:find("haze") then return "Cloudy" end
return "Fair"
end
local function heatIndexF(T, RH)
return -42.379 + 2.04901523*T + 10.14333127*RH - 0.22475541*T*RH
- 0.00683783*T*T - 0.05481717*RH*RH + 0.00122874*T*T*RH
+ 0.00085282*T*RH*RH - 0.00000199*T*T*RH*RH
end
local function windChillF(T, windMph)
return 35.74 + 0.6215*T - 35.75*(windMph^0.16) + 0.4275*T*(windMph^0.16)
end
local function computeFeelsLikeF(hiF, hum, windKmh)
local windMph = (tonumber(windKmh) or 0) * 0.621371
hiF = tonumber(hiF) or 0
hum = tonumber(hum) or 0
if hiF >= 80 and hum >= 40 then
return math.floor(heatIndexF(hiF, hum) + 0.5)
end
if hiF <= 50 and windMph >= 3 then
return math.floor(windChillF(hiF, windMph) + 0.5)
end
return hiF
end
local function computeCloudAndVis(nextInt, cond)
if cond == "Clear" then
return randInt(nextInt, 0, 20), randInt(nextInt, 15, 30)
elseif cond == "Cloudy" then
return randInt(nextInt, 35, 95), randInt(nextInt, 10, 25)
elseif cond == "Fog" then
return randInt(nextInt, 90, 100), randInt(nextInt, 1, 6)
elseif cond == "Rain" then
return randInt(nextInt, 70, 100), randInt(nextInt, 4, 15)
elseif cond == "Storm" then
return randInt(nextInt, 85, 100), randInt(nextInt, 2, 10)
elseif cond == "Snow" then
return randInt(nextInt, 80, 100), randInt(nextInt, 2, 10)
elseif cond == "Blizzard" then
return randInt(nextInt, 90, 100), randInt(nextInt, 1, 5)
elseif cond == "Dust" then
return randInt(nextInt, 20, 80), randInt(nextInt, 2, 10)
end
return randInt(nextInt, 10, 60), randInt(nextInt, 10, 25)
end
local function computeImpacts(cond, precipProb, windKmh, visKm, hiF, loF)
local impacts = { ground="OK", sea="OK", air="OK" }
precipProb = tonumber(precipProb) or 0
windKmh = tonumber(windKmh) or 0
visKm = tonumber(visKm) or 99
hiF = tonumber(hiF) or 0
loF = tonumber(loF) or 0
if visKm <= 1 or windKmh >= 55 or cond == "Blizzard" then
impacts.air = "No-Go"
elseif visKm <= 5 or windKmh >= 40 or cond == "Storm" then
impacts.air = "Limited"
end
if windKmh >= 50 or (cond == "Storm" and precipProb >= 85) or cond == "Blizzard" then
impacts.sea = "Closed"
elseif windKmh >= 28 or cond == "Storm" or (cond == "Rain" and precipProb >= 80) then
impacts.sea = "Restricted"
end
if (cond == "Snow" or cond == "Blizzard") and (loF <= 32 or visKm <= 3) then
impacts.ground = "Hazard"
elseif cond == "Storm" or (cond == "Rain" and precipProb >= 80) or visKm <= 5 then
impacts.ground = "Slow"
end
if hiF >= 100 and impacts.ground == "OK" then impacts.ground = "Slow" end
if loF <= 10 and impacts.ground == "OK" then impacts.ground = "Slow" end
return impacts
end
---------------------------------------------------------
-- 5) Ops Alert badge helpers
---------------------------------------------------------
local function alertLabel(level)
if level == 3 then return "Red" end
if level == 2 then return "Orange" end
if level == 1 then return "Yellow" end
return "Green"
end
local function alertColor(level)
if level == 3 then return "#f8d7da" end
if level == 2 then return "#ffe5cc" end
if level == 1 then return "#fff3cd" end
return "#d4edda"
end
local function spanBadge(level, text)
return string.format(
"<span style='background:%s;padding:2px 6px;border:1px solid #ccc;border-radius:10px;white-space:nowrap;'>%s</span>",
alertColor(level), text
)
end
local function formatImpact(imp)
imp = imp or {}
return string.format("Gnd: %s; Sea: %s; Air: %s", imp.ground or "OK", imp.sea or "OK", imp.air or "OK")
end
---------------------------------------------------------
-- 6) Climate ranges (°C base; shown °F)
---------------------------------------------------------
local climateTemperature = {
["Humid Subtropical"] = {
Atosiel = { hiMin=18, hiMax=26, loMin=10, loMax=16, humMin=60, humMax=80 },
Thalassiel = { hiMin=25, hiMax=34, loMin=19, loMax=24, humMin=65, humMax=90 },
Opsitheiel = { hiMin=20, hiMax=28, loMin=12, loMax=18, humMin=50, humMax=75 }
},
["Oceanic"] = {
Atosiel = { hiMin=10, hiMax=17, loMin=5, loMax=12, humMin=70, humMax=90 },
Thalassiel = { hiMin=14, hiMax=21, loMin=9, loMax=14, humMin=65, humMax=85 },
Opsitheiel = { hiMin=5, hiMax=12, loMin=1, loMax=6, humMin=70, humMax=90 }
},
["Subpolar Oceanic"] = {
Atosiel = { hiMin=3, hiMax=9, loMin=-2, loMax=3, humMin=70, humMax=95 },
Thalassiel = { hiMin=6, hiMax=12, loMin=1, loMax=6, humMin=70, humMax=90 },
Opsitheiel = { hiMin=-1, hiMax=4, loMin=-6, loMax=-1, humMin=75, humMax=95 }
},
["Mediterranean (Hot Summer)"] = {
Atosiel = { hiMin=15, hiMax=21, loMin=7, loMax=12, humMin=40, humMax=60 },
Thalassiel = { hiMin=25, hiMax=35, loMin=15, loMax=20, humMin=30, humMax=50 },
Opsitheiel = { hiMin=12, hiMax=18, loMin=5, loMax=10, humMin=45, humMax=65 }
},
["Hot Desert"] = {
Atosiel = { hiMin=25, hiMax=35, loMin=12, loMax=18, humMin=10, humMax=30 },
Thalassiel = { hiMin=35, hiMax=45, loMin=25, loMax=30, humMin=5, humMax=20 },
Opsitheiel = { hiMin=22, hiMax=30, loMin=10, loMax=16, humMin=5, humMax=25 }
},
["Cold Steppe"] = {
Atosiel = { hiMin=10, hiMax=18, loMin=2, loMax=8, humMin=30, humMax=50 },
Thalassiel = { hiMin=20, hiMax=28, loMin=10, loMax=15, humMin=25, humMax=45 },
Opsitheiel = { hiMin=0, hiMax=7, loMin=-6, loMax=0, humMin=35, humMax=55 }
},
["Hot Steppe"] = {
Atosiel = { hiMin=23, hiMax=30, loMin=12, loMax=18, humMin=20, humMax=40 },
Thalassiel = { hiMin=30, hiMax=40, loMin=20, loMax=25, humMin=15, humMax=35 },
Opsitheiel = { hiMin=25, hiMax=33, loMin=15, loMax=20, humMin=15, humMax=40 }
},
["Subarctic"] = {
Atosiel = { hiMin=0, hiMax=8, loMin=-10,loMax=-1, humMin=50, humMax=80 },
Thalassiel = { hiMin=5, hiMax=15, loMin=-1, loMax=5, humMin=50, humMax=85 },
Opsitheiel = { hiMin=-5, hiMax=0, loMin=-15,loMax=-5, humMin=60, humMax=90 }
}
}
---------------------------------------------------------
-- 7) Flavor strings (still keyed by climate/season)
---------------------------------------------------------
local climateEvents = {
["Humid Subtropical"] = {
Atosiel = {
"Morning drizzle and warm afternoon sunshine",
"Mild thunderstorm building by midday",
"Patchy fog at dawn, clearing toward lunch",
"Light rain with sunny breaks after noon",
"Overcast for part of the day, mild temperatures",
"Scattered clouds with a brief shower by dusk",
"Warm breezes carrying faint floral scents",
"Early morning seasonal storms and lake-driven floods may develop"
},
Thalassiel = {
"Hot, steamy day with intense midday heat",
"Tropical-like humidity, afternoon thunder possible",
"Intermittent heavy downpours, muggy evenings",
"High humidity and patchy thunderstorms late",
"Heat advisory with only brief cooling at night",
"Nighttime storms lingering into early morning",
"Afternoon heavy rains could trigger river floods"
},
Opsitheiel = {
"Warm daytime, gentle evening breezes",
"Occasional rain, otherwise mild temperatures",
"Fog at dawn, warm midday, pleasant night",
"Evening drizzle with mild breezes",
"Short-lived shower, then clearing skies",
"Evening cooling may lead to localized mudslides on steep slopes"
}
},
["Oceanic"] = {
Atosiel = {
"Frequent light rain, cool breezes all day",
"Foggy dawn, mild midmorning sunshine",
"Short sunbreaks among passing showers",
"Consistent drizzle, fresh winds from the sea",
"Morning fog with coastal storms and marsh flooding possible"
},
Thalassiel = {
"Light rain off and on, mild temperatures",
"Overcast with comfortable breezes throughout",
"Moist air with lingering fog near streams",
"Intermittent showers may escalate into flash floods and coastal storms"
},
Opsitheiel = {
"Overcast skies, cool drizzle through the day",
"Low visibility in morning fog, slow clearing",
"Heavier showers arriving late afternoon",
"Evening drizzle may develop into coastal gales and shoreline flooding"
}
},
["Subpolar Oceanic"] = {
Atosiel = {
"Near-freezing dawn, cold drizzle by midday",
"Overcast skies, mix of rain and sleet",
"Snowmelt water raising local streams",
"Cold drizzle combined with snowstorms and blizzards in higher areas"
},
Thalassiel = {
"Cool, short days with periodic drizzle",
"Short bursts of rain followed by fog",
"Misty conditions could prompt snowstorms and river floods"
},
Opsitheiel = {
"Steady cold rain mixing with wet snow",
"Freezing drizzle at dawn, raw gusty winds",
"Cloudy, damp day with potential sleet storms",
"Freezing drizzle may trigger avalanches in higher passes"
}
},
["Mediterranean (Hot Summer)"] = {
Atosiel = {
"Mild temperatures, bright sunshine, dry air",
"Sunny midday with a crisp, light wind",
"Short drizzly spell, then mostly clear",
"Bright skies overshadowed by potential heat advisory and droughts"
},
Thalassiel = {
"Very hot midday sun, minimal clouds",
"Heatwaves persisting, zero rain expected",
"Intense midday sun might lead to severe heat waves and dust storms"
},
Opsitheiel = {
"Cooler spells, brief showery intervals",
"Sporadic light rainfall, refreshing breezes",
"Cooling breezes could reduce temperatures, but localized brushfires and summer wildfires remain possible"
}
},
["Hot Desert"] = {
Atosiel = {
"Dry air, bright sunshine, no clouds in sight",
"Gentle breezes raising light sand by midday",
"Minor dust devil scouring the dunes",
"Scorching afternoons may be accompanied by dust storms and occasional mirage-like shimmers"
},
Thalassiel = {
"Blistering midday sun, risk of heat stroke",
"Occasional dust storm cutting visibility briefly",
"Extreme heat could combine with blowing sand to trigger potential sandstorms"
},
Opsitheiel = {
"Warm, mostly sunny with cooler nights",
"Occasional gust picking up desert grit",
"Evening cooling might still see intense heat with possible dust devils on dry slopes"
}
},
["Cold Steppe"] = {
Atosiel = {
"Cool mornings, moderate midday warmth, breezy",
"Light rain passing through grasslands midday",
"Variable cloud cover, mild temperature swings",
"Mild conditions could turn volatile with sudden flash floods and minor landslides"
},
Thalassiel = {
"Warm day, potential for gusty thunderstorms",
"Cloud buildup, short but intense showers possible",
"Rolling thunder near dusk, rain squalls possible",
"Afternoon heat may intensify, leading to thunderstorms, river floods, and gusty rain squalls"
},
Opsitheiel = {
"Wind-driven chill under gray skies",
"Possible light snowfall, especially overnight",
"Sparse precipitation, dryness persists, cold air",
"Chilly nights might bring frost and the risk of localized landslides on steep slopes"
}
},
["Hot Steppe"] = {
Atosiel = {
"Hot daytime sun, slight breeze, no rain",
"Gusty wind with dust swirling near midday",
"Scorching sun may lead to persistent dryness with a risk of brushfires and dust devils on dry slopes"
},
Thalassiel = {
"Brutally hot midday sun, patchy dust storms",
"Occasional swirling wind gusts, drifting dust",
"Intense heat may trigger severe dust storms and a potential heat wave"
},
Opsitheiel = {
"Hot days, moderate evenings, stable dryness",
"Dust devils possible over parched plains",
"Evening cooling might reduce temperatures, yet localized sandstorms and minor landslides remain a concern"
}
},
["Subarctic"] = {
Atosiel = {
"Snow melting, slushy paths, daytime sunshine",
"Mixed precipitation, cold rain at lower altitudes",
"Rapid thawing could spark river floods and snowstorms with heavy snowfall"
},
Thalassiel = {
"Short, cool days, moderate sunshine at times",
"Drizzle commonly, heavier rainfall occasionally",
"Cool days may be interrupted by sudden blizzard-like conditions and heavy rain squalls"
},
Opsitheiel = {
"Early snowfall returning, freezing ground rapidly",
"Blizzard-like conditions with large snow accumulations",
"Deep winter chill may result in persistent blizzards and avalanches in higher passes"
}
}
}
---------------------------------------------------------
-- 8) Triggered advisory keywords (optional extra advisory layer)
---------------------------------------------------------
local cityForecastOverrides = {
["Hamarrfell"] = {
Atosiel = {
"Late snowpack lingering on ridge roads, cold meltwater in the lower streets",
"Fog in the ropeway approaches, sleet over the upper passes",
"Sharp mountain wind with thawing snow on the lower approaches",
"Cold drizzle below, fresh snowfall returning across the higher road cuttings"
},
Thalassiel = {
"Short cool day with clear intervals, but fog holding in the upland cuts",
"Mountain rain and low cloud drifting across the high road",
"Cool highland air with sudden mist over the ropeway line",
"Breezy conditions in the staging yards, cloud gathering over the passes"
},
Opsitheiel = {
"Early snow returning to the ridgelines, freezing ground after dusk",
"Blizzard conditions in the higher passes, severe wind over exposed roads",
"Hard frost in the city with drifting snow on the upland approaches",
"Snow squalls and low visibility across the ropeway and pass network"
}
}
}
local triggeredDisasters = {
{ keywords={"seasonal storms","lake%-driven floods"}, hazard="Seasonal storms and lake-driven floods" },
{ keywords={"river floods","heavy rains"}, hazard="River floods during heavy rains" },
{ keywords={"snowstorms","heavy snowfall"}, hazard="Snowstorms / heavy snowfall" },
{ keywords={"avalanch"}, hazard="Avalanche risk" },
{ keywords={"landslides","mudslides"}, hazard="Landslides / mudslides" },
{ keywords={"drought","persistent dryness","dry conditions"}, hazard="Drought / elevated fire risk" },
{ keywords={"brushfires","wildfires"}, hazard="Brushfire / wildfire risk" },
{ keywords={"dust storm","sandstorm","blowing sand"}, hazard="Dust / sandstorm risk" },
{ keywords={"fog","low visibility"}, hazard="Fog-related hazards" },
{ keywords={"severe storm","thunder"}, hazard="Severe storm / lightning risk" },
{ keywords={"storm surges","shoreline flooding","coastal gales"}, hazard="Coastal flooding / surge risk" }
}
local windDirections = { "N","NE","E","SE","S","SW","W","NW" }
---------------------------------------------------------
-- 9) City registry (ALL cities) + climate assignment
-- NOTE: Notranskja and Tonar are not explicitly in the nation Climate table;
-- they are assigned plausible climates consistent with their dependency regions.
---------------------------------------------------------
local cityData = {
-- Core major
{ name="Vaeringheim", climate="Humid Subtropical" },
{ name="Luminaria", climate="Oceanic" },
{ name="Serena", climate="Subpolar Oceanic" },
{ name="Pyralis", climate="Oceanic" },
{ name="Symphonara", climate="Oceanic" },
{ name="Aurelia", climate="Mediterranean (Hot Summer)" },
{ name="Somniumpolis", climate="Humid Subtropical" },
{ name="Nexa", climate="Oceanic" },
{ name="Lunalis Sancta", climate="Oceanic" },
{ name="Sylvapolis", climate="Humid Subtropical" },
-- Core minor
{ name="Saluria", climate="Oceanic" },
{ name="Aetherium", climate="Subarctic" },
{ name="Ferrum Citadel", climate="Hot Desert" },
{ name="Acheron", climate="Cold Steppe" },
{ name="Erythros", climate="Oceanic" },
{ name="Catonis Atrium", climate="Oceanic" },
{ name="Delphica", climate="Oceanic" },
{ name="Koinonía", climate="Oceanic" },
{ name="Aureum", climate="Mediterranean (Hot Summer)" },
-- Alperkin
{ name="The Alpazkigz", climate="Cold Steppe" }, -- plausible high-steppe/plateau mix; adjust if you later codify it
{ name="Odiferia", climate="Humid Subtropical" }, -- wetland belt; adjust if you later codify it
-- New South Jangsong (major)
{ name="Skýrophos", climate="Oceanic" },
{ name="Bjornopolis", climate="Oceanic" },
{ name="Aegirheim", climate="Subarctic" },
{ name="Norsolyra", climate="Oceanic" },
{ name="Thorsalon", climate="Oceanic" },
-- New South Jangsong (minor)
{ name="Pelagia", climate="Hot Steppe" },
{ name="Myrene", climate="Oceanic" },
{ name="Thyrea", climate="Humid Subtropical" },
{ name="Ephyra", climate="Subpolar Oceanic" },
{ name="Halicarn", climate="Mediterranean (Hot Summer)" },
-- Haifan Bassaridia (major)
{ name="Keybir-Aviv", climate="Humid Subtropical" },
{ name="Tel-Amin", climate="Mediterranean (Hot Summer)" },
{ name="Diamandis", climate="Mediterranean (Hot Summer)" },
{ name="Jogi", climate="Oceanic" },
{ name="Lewisburg", climate="Humid Subtropical" },
-- Haifan Bassaridia (minor)
{ name="Thermosalem", climate="Oceanic" },
{ name="Akróstadium", climate="Cold Steppe" },
{ name="Sufriya", climate="Humid Subtropical" },
{ name="Lykopolis", climate="Oceanic" },
-- Normark
{ name="Ardclach", climate="Subarctic" },
{ name="Riddersborg", climate="Subpolar Oceanic" },
-- Ouriana (province)
{ name="Bashkim", climate="Cold Steppe" },
{ name="Ourid", climate="Cold Steppe" },
-- Ourianian dependency
{ name="Tonar", climate="Cold Steppe" },
-- Caledonian dependencies (canonical list)
{ name="Fanghorn", climate="Subarctic" },
{ name="Eikbu", climate="Subarctic" },
{ name="Galvø", climate="Subarctic" },
{ name="Sårensby", climate="Subpolar Oceanic" },
{ name="Slevik", climate="Subpolar Oceanic" },
{ name="Sjøsborg", climate="Subpolar Oceanic" },
{ name="Storesund", climate="Subpolar Oceanic" },
{ name="Notranskja", climate="Subarctic" }, -- not listed in nation Climate table; set consistent with nearby Caledonian Dfc cities
{ name="Kaledonija", climate="Subarctic" },
{ name="Skøda", climate="Subarctic" },
{ name="Krlsgorod", climate="Subarctic" },
{ name="Hamarrfell", climate="Subarctic" },
}
---------------------------------------------------------
-- 10) Ops alert computation
---------------------------------------------------------
local function computeAlert(nextInt, cond, impacts, precipProb, windKmh, visKm, hiF, loF, forecastText)
local level = 0
local hazard = "No reports"
local function bump() level = math.min(3, level + 1) end
precipProb = tonumber(precipProb) or 0
windKmh = tonumber(windKmh) or 0
visKm = tonumber(visKm) or 99
hiF = tonumber(hiF) or 0
loF = tonumber(loF) or 0
if impacts and (impacts.air ~= "OK" or impacts.sea ~= "OK" or impacts.ground ~= "OK") then bump() end
if impacts and (impacts.air == "No-Go" or impacts.sea == "Closed" or impacts.ground == "Hazard") then bump(); bump() end
if windKmh >= 30 or visKm <= 5 or precipProb >= 85 then bump() end
if hiF >= 105 or loF <= 5 then bump() end
if cond == "Storm" then hazard = "Severe storm / lightning risk"
elseif cond == "Rain" then hazard = "Heavy rain / localized flooding"
elseif cond == "Fog" then hazard = "Low visibility / navigation hazard"
elseif cond == "Blizzard" then hazard = "Blizzard / whiteout conditions"
elseif cond == "Snow" then hazard = "Snow/ice / hazardous travel"
elseif cond == "Dust" then hazard = "Dust/sand reduction in visibility"
else
if hiF >= 100 then hazard = "Heat stress conditions"
elseif loF <= 10 then hazard = "Extreme cold exposure risk"
else hazard = "No reports" end
end
local extras = {}
local t = (forecastText or ""):lower()
for _, item in ipairs(triggeredDisasters) do
for _, kw in ipairs(item.keywords or {}) do
if t:find(kw) then
local pHit = (level >= 2) and 0.35 or 0.10
if rand01(nextInt) <= pHit then extras[#extras+1] = item.hazard end
break
end
end
end
local recommend = { hatch=false, missionary=false }
if impacts and (impacts.sea ~= "OK" or impacts.air ~= "OK") then recommend.hatch = true end
if impacts and impacts.ground ~= "OK" then recommend.missionary = true end
if hiF >= 100 or loF <= 10 then recommend.missionary = true end
return {
level = level,
label = alertLabel(level),
hazard = hazard,
impacts = impacts or {ground="OK", sea="OK", air="OK"},
recommend = recommend,
advisory = (#extras > 0) and table.concat(extras, "; ") or "No reports"
}
end
---------------------------------------------------------
-- 11) Core forecast generator (deterministic)
---------------------------------------------------------
local function makeForecastForCity(cityName, climateName, year, dayOfYear)
local season = getSeasonName(dayOfYear)
local nextInt = lcg(hash31(string.format("wx:%d:%03d:%s", year, dayOfYear, cityName)))
local seasonTbl =
(cityForecastOverrides[cityName] and cityForecastOverrides[cityName][season])
or (climateEvents[climateName] and climateEvents[climateName][season])
local forecastStr = (seasonTbl and #seasonTbl > 0) and pickFromList(nextInt, seasonTbl) or "No data"
local cond = conditionFromText(forecastStr)
local tdata = climateTemperature[climateName] and climateTemperature[climateName][season]
if not tdata then
-- safety fallback if a climate key is missing
tdata = climateTemperature["Oceanic"][season]
end
local hiC = randInt(nextInt, tdata.hiMin, tdata.hiMax)
local loC = randInt(nextInt, tdata.loMin, tdata.loMax)
local hum = randInt(nextInt, tdata.humMin, tdata.humMax)
local precipProb = randInt(nextInt, 0, 100)
local fLower = (forecastStr or ""):lower()
if fLower:find("rain") or fLower:find("drizzle") or fLower:find("downpour") or fLower:find("shower")
or fLower:find("snow") or fLower:find("storm") or fLower:find("thunder") or fLower:find("sleet")
then
precipProb = randInt(nextInt, 70, 99)
end
local precipType = "None"
if cond == "Rain" or cond == "Storm" then precipType = "Rain"
elseif cond == "Snow" or cond == "Blizzard" then precipType = "Snow" end
local windDir = windDirections[(nextInt() % #windDirections) + 1]
local windKmh
if cond == "Storm" then windKmh = randInt(nextInt, 22, 55)
elseif cond == "Blizzard" then windKmh = randInt(nextInt, 20, 50)
elseif cond == "Snow" then windKmh = randInt(nextInt, 10, 40)
elseif cond == "Dust" then windKmh = randInt(nextInt, 15, 45)
else windKmh = randInt(nextInt, 0, 28) end
local gustKmh = math.min(90, windKmh + randInt(nextInt, 5, 30))
local cloud, visKm = computeCloudAndVis(nextInt, cond)
local hiF, loF = cToF(hiC), cToF(loC)
local feelsF = computeFeelsLikeF(hiF, hum, windKmh)
local impacts = computeImpacts(cond, precipProb, windKmh, visKm, hiF, loF)
local alert = computeAlert(nextInt, cond, impacts, precipProb, windKmh, visKm, hiF, loF, forecastStr)
return {
name = cityName,
climate = climateName,
season = season,
condition = cond,
hiF = hiF, loF = loF, feelsF = feelsF,
humidity = hum,
precipType = precipType, precipProb = precipProb,
windDir = windDir, windKmh = windKmh, gustKmh = gustKmh,
cloud = cloud, visKm = visKm,
forecast = forecastStr,
ops = alert
}
end
---------------------------------------------------------
-- 12) Exported Ops API
---------------------------------------------------------
function p.getOpsData(cityName, year, dayOfYear)
cityName = tostring(cityName or "")
local y = tonumber(year)
local d = tonumber(dayOfYear)
if not y or not d then
local di = getDateInfo(nil)
y, d = di.year, di.dayOfYear
end
local climate = nil
for _, e in ipairs(cityData) do
if e.name == cityName then climate = e.climate break end
end
if not climate then return nil end
local fc = makeForecastForCity(cityName, climate, y, d)
if not fc then return nil end
return {
city = fc.name,
climate = fc.climate,
season = fc.season,
condition = fc.condition,
hiF = fc.hiF, loF = fc.loF, feelsF = fc.feelsF,
humidity = fc.humidity,
precipType = fc.precipType,
precipProb = fc.precipProb,
windDir = fc.windDir,
windKmh = fc.windKmh,
gustKmh = fc.gustKmh,
cloud = fc.cloud,
visKm = fc.visKm,
impacts = fc.ops.impacts,
alert = {
level = fc.ops.level,
label = fc.ops.label,
hazard = fc.ops.hazard,
recommend = fc.ops.recommend,
advisory = fc.ops.advisory
}
}
end
function p.opsAlert(frame)
local args = (frame and frame.args) or {}
local di = getDateInfo(args)
local city = tostring(args.city or "")
if city == "" then
return "Error: city parameter required. Example: {{#invoke:BassaridiaForecast|opsAlert|city=Vaeringheim}}"
end
local op = p.getOpsData(city, di.year, di.dayOfYear)
if not op then return "Error: unknown city '" .. city .. "'." end
local badge = spanBadge(op.alert.level, op.alert.label .. " – " .. (op.condition or ""))
return string.format("%s<br/>%s<br/>%s", badge, formatImpact(op.impacts), op.alert.hazard or "No reports")
end
---------------------------------------------------------
-- 13) Forecast tables
---------------------------------------------------------
function p.weatherForecast(frame)
local args = (frame and frame.args) or {}
local di = getDateInfo(args)
local dayOfYear, yearNumber = di.dayOfYear, di.year
local seasonName = getSeasonName(dayOfYear)
local out = {}
table.insert(out, "== Daily Weather Forecast ==")
table.insert(out, string.format("''(Day %d of Year %d PSSC, %s)''", dayOfYear, yearNumber, seasonName))
table.insert(out, "")
table.insert(out, '<div style="overflow-x:auto;">')
table.insert(out, '{| class="wikitable sortable" style="width:100%; text-align:left;"')
table.insert(out, table.concat({
"! City",
"! Climate",
"! Season",
"! Condition",
"! High °F",
"! Low °F",
"! Feels Like °F",
"! Humidity (%)",
"! Precip",
"! Wind Dir",
"! Wind (km/h)",
"! Gust (km/h)",
"! Cloud (%)",
"! Vis (km)",
"! Ops Impact",
"! Ops Alert",
"! Today's Weather",
"! Natural Disaster Advisory"
}, "\n"))
for _, entry in ipairs(cityData) do
local fc = makeForecastForCity(entry.name, entry.climate, yearNumber, dayOfYear)
if fc then
local cityCell = cityFlagMarkup(fc.name, 20) .. " " .. cityLinkMarkup(fc.name)
local opsBadge = spanBadge(fc.ops.level, fc.ops.label)
local precipCell = string.format("%s %d%%", fc.precipType, fc.precipProb)
table.insert(out, "|-")
table.insert(out, string.format(
"| %s\n| %s\n| %s\n| %s\n| %d\n| %d\n| %d\n| %d\n| %s\n| %s\n| %d\n| %d\n| %d\n| %d\n| %s\n| %s<br/>%s\n| %s\n| %s",
cityCell, fc.climate, fc.season, fc.condition,
fc.hiF, fc.loF, fc.feelsF, fc.humidity,
precipCell, fc.windDir, fc.windKmh, fc.gustKmh,
fc.cloud, fc.visKm,
formatImpact(fc.ops.impacts),
opsBadge, fc.ops.hazard,
fc.forecast,
fc.ops.advisory
))
end
end
table.insert(out, "|}")
table.insert(out, "</div>")
return table.concat(out, "\n")
end
function p.weatherForCity(frame)
local args = (frame and frame.args) or {}
local cityRequested = tostring(args.city or "")
if cityRequested == "" then
return "Error: Please specify a city. E.g. {{#invoke:BassaridiaForecast|weatherForCity|city=Vaeringheim}}"
end
local di = getDateInfo(args)
local climate = nil
for _, e in ipairs(cityData) do
if e.name == cityRequested then climate = e.climate break end
end
if not climate then
return "Error: City '" .. cityRequested .. "' not found in city registry."
end
local fc = makeForecastForCity(cityRequested, climate, di.year, di.dayOfYear)
if not fc then
return "Error: Forecast unavailable for city '" .. cityRequested .. "'."
end
local opsBadge = spanBadge(fc.ops.level, fc.ops.label .. " – " .. fc.condition)
local precipCell = string.format("%s %d%%", fc.precipType, fc.precipProb)
local cityCell = cityFlagMarkup(fc.name, 20) .. " " .. cityLinkMarkup(fc.name)
local out = {}
table.insert(out, '{| class="wikitable" style="width:100%; text-align:left;"')
table.insert(out, table.concat({
"! City",
"! Climate",
"! Season",
"! Condition",
"! High °F",
"! Low °F",
"! Feels Like °F",
"! Humidity (%)",
"! Precip",
"! Wind (dir / km/h / gust)",
"! Cloud (%)",
"! Vis (km)",
"! Ops Impact",
"! Ops Alert",
"! Today's Weather",
"! Natural Disaster Advisory"
}, "\n"))
table.insert(out, "|-")
table.insert(out, string.format(
"| %s\n| %s\n| %s\n| %s\n| %d\n| %d\n| %d\n| %d\n| %s\n| %s / %d / %d\n| %d\n| %d\n| %s\n| %s<br/>%s\n| %s\n| %s",
cityCell, fc.climate, fc.season, fc.condition,
fc.hiF, fc.loF, fc.feelsF, fc.humidity,
precipCell,
fc.windDir, fc.windKmh, fc.gustKmh,
fc.cloud, fc.visKm,
formatImpact(fc.ops.impacts),
opsBadge, fc.ops.hazard,
fc.forecast,
fc.ops.advisory
))
table.insert(out, "|}")
return table.concat(out, "\n")
end
---------------------------------------------------------
-- 14) Stars for tonight (deterministic)
---------------------------------------------------------
local observerLat = 38.0
local starChartData = {
{ name="Azos", starClass="Host Star", lat=62.0 },
{ name="Danaß", starClass="Host Star", lat=54.0 },
{ name="Aprobelle", starClass="Host Star", lat=46.0 },
{ name="Eos", starClass="Host Star", lat=40.0 },
{ name="Thalassa", starClass="Host Star", lat=34.0 },
{ name="Cato", starClass="Host Star", lat=28.0 },
{ name="Noctis", starClass="Host Star", lat=22.0 }
}
function p.starsForTonight(frame)
local args = (frame and frame.args) or {}
local di = getDateInfo(args)
local nextInt = lcg(hash31(string.format("stars:%d:%03d", di.year, di.dayOfYear)))
local function isVisibleAt630(lat)
local offset = randInt(nextInt, 5, 55)
return (lat < (observerLat + offset))
end
local out = {}
table.insert(out, "=== Northern Host Stars Visible at ~6:30 PM ===")
table.insert(out, "")
table.insert(out, '{| class="wikitable" style="width:100%; text-align:left;"')
table.insert(out, "! Star !! Class !! Star-Lat !! Visible? !! Approx. Altitude")
for _, star in ipairs(starChartData) do
local yesNo, alt = "No", 0
if isVisibleAt630(star.lat) then
yesNo = "Yes"
alt = randInt(nextInt, 20, 80)
end
table.insert(out, "|-")
table.insert(out, string.format("| %s || %s || %.1f°N || %s || %d°", star.name, star.starClass, star.lat, yesNo, alt))
end
table.insert(out, "|}")
return table.concat(out, "\n")
end
return p
