25:["$","title",null,{"children":"Victoria 3 resource map v2.4 before game data update | mheard03 | Observable"}] 49:Tbab,function applyMapStyles(mapSvg) { const defs = svg` `; const style = svg` `; const selector = [defs, style].map(e => `svg > #${e.id}`).join(", "); [...mapSvg.querySelectorAll(selector)].forEach(e => e.remove()); mapSvg.prepend(defs, style); }4a:T61e,rollupFields = { let landLookup = { land: { id: "land", name: "Land", colorNum: ColorNum.fromHex("#00000099") } }; let centralizationLookup = { false: { id: "centralized", name: "Centralized countries", colorNum: Object.values(countries).find(c => !c.isDecentralized).colorNum }, true: { id: "decentralized", name: "Decentralized countries", colorNum: Object.values(countries).find(c => c.isDecentralized).colorNum } }; let tracedLookup = _.chain(Object.values(provinces)) .groupBy(p => [p.state, p.region, countries[p.country].isDecentralized].join("|")) .value(); for (let [key, provinces] of Object.entries(tracedLookup)) { tracedLookup[key] = { id: key, colorNum: provinces[0].colorNum } } let rollupFields = { land: { zIndex: 0, singular: "land", plural: "land", lookup: landLookup }, states: { zIndex: 1, singular: "state", plural: "states", lookup: states }, regions: { zIndex: 2, singular: "region", plural: "regions", lookup: regions }, centralization: { zIndex: 3, singular: "centralization", plural: "centralization", lookup: centralizationLookup } // traced: { singular: "traced", plural: "traced", lookup: tracedLookup } }; rollupFields.land.getLookupId = (p => "land"); rollupFields.centralization.getLookupId = (p => !!countries[p.country].isDecentralized); // rollupFields.traced.getLookupId = (p => p.traceKey); for (let rollupField of Object.values(rollupFields)) { rollupField.getLookupId ??= (p => p[rollupField.singular]); } return rollupFields; }4b:T7f4,getColorScale = { const yellow = colorScaleBasis.yellow; const green = colorScaleBasis.green; const maxC = _.min(Object.values(colorScaleBasis).map(c => c.get("c"))); const minC = 0.1 * maxC; const intensityToCscale = d3.scaleLinear().domain([0,1]).range([minC, maxC]); const cToJscaleGreen = d3.scaleLinear().domain([0, maxC]).range([100, green.get("j")]); const cToJscaleYellow = d3.scaleLinear().domain([0, maxC]).range([100, yellow.get("j")]); const pctDiscoveredToHueScale = d3.scaleLinear().domain([0,1]).range([yellow.get("h"), green.get("h")]); function getColor(intensity, pctDiscovered) { if (intensity < 0.1); let c = intensityToCscale(intensity); let fullGreen = new Color("jch", [cToJscaleGreen(c), c, green.get("h")]); let fullYellow = new Color("jch", [cToJscaleYellow(c), c, yellow.get("h")]); fullGreen.coords = fullGreen.coords.map(c => c * pctDiscovered); fullYellow.coords = fullYellow.coords.map(c => c * (1 - pctDiscovered)); let mixed = new Color("jch", fullGreen.coords.map((c, i) => c + fullYellow.coords[i])); return mixed.toGamut("srgb").to("srgb").toString({ format: "hex" }); } function getColorScale(goodId, geo = "states") { let levels = resourceLevels[goodId]; let quantities = Object.values(levels[geo]); let maxTotalPresent = _.max(quantities.map(s => s.discovered + s.undiscovered)); let maxDiscovered = _.max(quantities.map(s => s.discovered / (s.discovered + s.undiscovered))); let maxUndiscovered = _.max(quantities.map(s => s.undiscovered / (s.discovered + s.undiscovered))); return function(discovered, undiscovered) { if (discovered == 0 && undiscovered == 0) return "revert-layer"; // This is a no-op since it's going in the style tag let totalPresent = (discovered + undiscovered); let pctDiscovered = discovered / totalPresent; let intensity = totalPresent / maxTotalPresent; return getColor(intensity, pctDiscovered); } } return getColorScale; }4c:T90b,resourceLevels = { let goodBgEras = {}; for (let { id: bgId, outputEras } of Object.values(resourceBuildingGroups)) { for (let [output, eraNum] of Object.entries(outputEras)) { goodBgEras[output] ??= {}; goodBgEras[output][bgId] = eraNum; } } let resourceLevels = {}; for (let [goodId, buildingGroups] of Object.entries(goodBgEras)) { if (common.goods[goodId].category == "staple") continue; let good = resourceLevels[goodId] ??= { goodId, category: common.goods[goodId].category, buildings: [], states: {}, regions: {} }; for (let [bgId, eraNum] of Object.entries(buildingGroups)) { good.buildings.push(...resourceBuildingGroups[bgId].buildings); for (let state of Object.values(states).filter(s => s.resources[bgId])) { let stateBgCounts = state.resources[bgId]; let stateGoodCounts = good.states[state.id] ??= { discovered: 0, undiscovered: 0 }; let regionGoodCounts = good.regions[state.region] ??= { discovered: 0, undiscovered: 0 }; stateGoodCounts.undiscovered += stateBgCounts.undiscovered; stateGoodCounts.discovered += stateBgCounts.discovered; regionGoodCounts.undiscovered += stateBgCounts.undiscovered; regionGoodCounts.discovered += stateBgCounts.discovered; } } } /* // Calculate totals and collapse sets for (let { quantities, states, regions } of Object.values(resourceLevels)) { quantities.total = _.sum(Object.values(quantities)); states.presentIn = addMembers(new Set(), ...Object.values(states)); regions.presentIn = addMembers(new Set(), ...Object.values(regions)); // Object.entries(states).forEach(([key, value]) => states[key] = value.size); // Object.entries(regions).forEach(([key, value]) => regions[key] = value.size); } let regionCount = Object.keys(regions).length; for (let { goodId, quantities, states, regions } of Object.values(resourceLevels)) { let good = resourceLevels[goodId]; let stats = good.stats = {}; stats.rarity = regions.presentIn.size / regionCount; stats.perRegion = quantities.total / regions.presentIn.size; stats.perState = quantities.total / states.presentIn.size; } */ return sortObjectBy(resourceLevels, "category", "goodId"); }4d:Taf2,_resourceLevels = { function addMembers(target, ...otherSets) { for (let otherSet of otherSets) { for (let e of otherSet) { target.add(e); } } return target; } let goodBgEras = {}; for (let { id: bgId, outputEras } of Object.values(resourceBuildingGroups)) { for (let [output, eraNum] of Object.entries(outputEras)) { goodBgEras[output] ??= {}; goodBgEras[output][bgId] = eraNum; } } let resourceLevels = {}; for (let [goodId, buildingGroups] of Object.entries(goodBgEras)) { if (common.goods[goodId].category == "staple") continue; let good = resourceLevels[goodId] ??= { goodId, category: common.goods[goodId].category, buildings: [], quantities: { known: 0, unlockable: 0, discoverable: 0 }, states: { knownIn: new Set(), unlockableIn: new Set(), discoverableIn: new Set() }, regions: { knownIn: new Set(), unlockableIn: new Set(), discoverableIn: new Set() } }; for (let [bgId, eraNum] of Object.entries(buildingGroups)) { good.buildings.push(...resourceBuildingGroups[bgId].buildings); let bgStats = _bgResourceStats[bgId]; good.quantities.discoverable += bgStats.undiscovered; addMembers(good.states.discoverableIn, bgStats.undiscoveredInStates); addMembers(good.regions.discoverableIn, bgStats.undiscoveredInRegions); if (eraNum <= 1) { good.quantities.known += bgStats.discovered; addMembers(good.states.knownIn, bgStats.discoveredInStates); addMembers(good.regions.knownIn, bgStats.discoveredInRegions); } else { good.quantities.unlockable += bgStats.discovered; addMembers(good.states.knownIn, bgStats.discoveredInStates); addMembers(good.regions.knownIn, bgStats.discoveredInRegions); } } } // Calculate totals and collapse sets for (let { quantities, states, regions } of Object.values(resourceLevels)) { quantities.total = _.sum(Object.values(quantities)); states.presentIn = addMembers(new Set(), ...Object.values(states)); regions.presentIn = addMembers(new Set(), ...Object.values(regions)); // Object.entries(states).forEach(([key, value]) => states[key] = value.size); // Object.entries(regions).forEach(([key, value]) => regions[key] = value.size); } let regionCount = Object.keys(regions).length; for (let { goodId, quantities, states, regions } of Object.values(resourceLevels)) { let good = resourceLevels[goodId]; let stats = good.stats = {}; stats.rarity = regions.presentIn.size / regionCount; stats.perRegion = quantities.total / regions.presentIn.size; stats.perState = quantities.total / states.presentIn.size; } return sortObjectBy(resourceLevels, "category", "goodId"); }4e:T625,resourceBuildingGroups = { function getChildGroupIds(buildingGroupId) { let childGroupIds = Object.entries(common.building_groups) .filter(e => e[1].parent_group == buildingGroupId) .map(e => e[0]); return [...childGroupIds, ...childGroupIds.flatMap(id => getChildGroupIds(id))]; } // Get all the building groups associated with state resources let resourceBgIds = new Set(); for (let stateDef of Object.values(common.map_data.state_regions)) { (stateDef.arable_resources || []).forEach(bg => resourceBgIds.add(bg)); Object.keys(stateDef.capped_resources || {}).forEach(bg => resourceBgIds.add(bg)); (stateDef.resource || []).flatMap(r => [r.type, r.depleted_type]).forEach(bg => resourceBgIds.add(bg)); } resourceBgIds.delete(undefined); // Populate buildingGroup data for ids in resourceBgIds let buildingGroups = {}; for (let [id, bgDef] of Object.entries(common.building_groups).filter(e => resourceBgIds.has(e[0]))) { let childrenAndSelfIds = [id, ...getChildGroupIds(id)]; let buildingDefs = Object.values(common.buildings) .filter(b => childrenAndSelfIds.includes(b.building_group)); let outputEras = {}; for (let buildingDef of buildingDefs) { for (let [output, eraNum] of Object.entries(getBuildingOutputEras(buildingDef))) { outputEras[output] = Math.min(eraNum, outputEras[output] ??= 10); } } buildingGroups[id] = { id, buildings: buildingDefs.map(b => b._id), outputEras }; } return sortObjectByKeys(buildingGroups); }4f:T769,states = { function add(target, field, value) { target[field] ??= 0; target[field] += value; } let states = {}; for (let [id, stateDef] of Object.entries(common.map_data.state_regions)) { if (!stateDef.arable_land) continue; let state = states[id] = { id, name: loc.tryGetText(id), region: stateDef.region, traits: [...(stateDef.traits || [])], resources: {} }; // populate resources for (let bgId of stateDef.arable_resources ?? []) { state.resources[bgId] = { discovered: stateDef.arable_land, undiscovered: 0 }; } for (let [bgId, discovered] of Object.entries(stateDef.capped_resources || {})) { state.resources[bgId] = { discovered, undiscovered: 0 }; } for (let {type: bgId, discovered_amount, undiscovered_amount} of (stateDef.resource || [])) { state.resources[bgId] ??= { discovered: 0, undiscovered: 0 }; state.resources[bgId].discovered += discovered_amount ?? 0; state.resources[bgId].undiscovered += undiscovered_amount ?? 0; } } // provinces for (let [nsStateId, stateDef] of Object.entries(common.history.states)) { let state = states[nsStateId.split(":").pop()]; state.provinces = []; state.countries = []; state.countryProvinces = {}; let countryProvinces = {}; for (let { country: nsCountryId, owned_provinces } of stateDef.create_state) { let countryId = nsCountryId.split(":").pop(); state.provinces.push(...owned_provinces); state.countries.push(countryId); state.countryProvinces[countryId] = owned_provinces; state.colorNum = ColorNum.fromPdx(state.provinces[0]); } } // regions for (let [regionId, regionDef] of Object.entries(common.strategic_regions)) { regionDef.states.map(id => states[id]).filter(s => s).forEach(s => s.region = regionId); } return states; }50:T14e5,common = { let createdNodes = []; let common = {}; let flatCache = new Map(); function cacheObject(objPath, key, value) { if (!flatCache.has(key)) flatCache.set(key, []); flatCache.get(key).push({ objPath, value }); } function setIdsForObjectKeys(obj) { for (let [key, value] of Object.entries(obj)) { if (value !== undefined && typeof(value) == "object" && !Array.isArray(value)) { value._id = key; } } return obj; } function coerceToArray(obj, path) { let pathTerms = path.split("."); let nextProp = pathTerms[0]; if (nextProp.includes("*")) { let keys = Object.keys(obj); if (!keys.length) return; if (nextProp != "*") { if ([...nextProp].filter(char => char == "*").length > 1) { throw `Max one asterisk per path term. (Received ${nextProp})` } let stub = nextProp.replace("*", "") if (nextProp.startsWith("*")) { keys = keys.filter(k => k.endsWith(stub)); } else if (nextProp.endsWith("*")) { keys = keys.filter(k => k.startsWith(stub)); } else { throw `Asterisks can't appear in the middle of a path term. (Received ${nextProp})` } } if (!keys.length) return; let newPaths = keys.map(k => [k, ...pathTerms.slice(1)].join(".")); newPaths.forEach(p => coerceToArray(obj, p)); return; } else if (!obj[nextProp]) { return; } let nextPath = pathTerms.slice(1).join("."); if (nextPath) { coerceToArray(obj[nextProp], nextPath); return; } let value = obj[nextProp]; if (value === undefined) { obj[nextProp] = []; } else if (!Array.isArray(value)) { obj[nextProp] = [value]; } } function getFilesInDir(dirPath) { if (!dirPath.endsWith("/")) dirPath += "/"; return gameDataZip.filenames.filter(f => { if (!f.startsWith(dirPath)) return false; if (!f.endsWith(".txt")) return false; return f.replace(dirPath, "").split("/").filter(d => d).length == 1; }); } function getObjectPath(dirArray) { let objPath = []; while (dirArray.length) { let propName = dirArray.shift(); propName = propName.replaceAll(".", "_"); objPath.push(propName); } return objPath.join("."); } function getOrCreateTargetAtPath(objPath) { let propNames = objPath.split("."); let target = common; while (propNames.length) { let propName = propNames.shift(); target[propName] ??= {}; target = target[propName]; } return target; } async function loadFolder(dirPath, options = {}) { let dirArray = dirPath.split("/").filter(d => d); if (dirArray[0]?.toLowerCase() == "common") dirArray = dirArray.slice(1); options = Object.assign({ setIds: true, objPath: undefined, postProcess: e => e, makeArray: [] }, options); options.objPath ??= getObjectPath(dirArray); let { setIds, objPath, postProcess, makeArray } = options; if (makeArray && !Array.isArray(makeArray)) makeArray = [makeArray]; let filePaths = getFilesInDir(dirPath); let target = getOrCreateTargetAtPath(options.objPath); for (let filePath of filePaths) { let text = await gameDataZip.file(filePath).text(); text = text.replace(/^[\s]*/, ""); let parsed = jomini.parseText2(text, setIds); if (postProcess) parsed = postProcess(parsed); if (makeArray.length) { for (let obj of Object.values(parsed)) { makeArray.forEach(path => coerceToArray(obj, path)); } } if (setIds) { setIdsForObjectKeys(parsed); Object.entries(parsed).forEach(e => cacheObject(objPath, ...e)); } Object.assign(target, parsed); } } await loadFolder("common/building_groups"); await loadFolder("common/buildings"); await loadFolder("common/country_definitions", { setIds: false }); await loadFolder("common/goods"); await loadFolder("common/history/states", { setIds: false, postProcess: e => e.STATES, makeArray: ["create_state", "add_homeland"] }); await loadFolder("common/history/buildings", { setIds: false, postProcess: e => e.BUILDINGS, makeArray: ["create_building"] }); await loadFolder("common/laws"); await loadFolder("common/production_method_groups"); await loadFolder("common/production_methods"); await loadFolder("common/strategic_regions"); await loadFolder("common/technology/eras", { setIds: false, objPath: "eras" }); await loadFolder("common/technology/technologies", { objPath: "technologies" }); await loadFolder("map_data/state_regions", { setIds: false, makeArray: ["arable_resources", "resource"] }); visitAll(common, v => { if (v !== undefined && typeof(v) == "object") { Object.freeze(v); } }); // Common.find as accessor to flatCache common.find = function(id) { let cached = flatCache.get(id); if (cached?.length == 1) return cached[0].value; if (cached?.length > 1) { let paths = cached.map(c => c.objPath); try { throw new Error(`Error in common.find: ${id} is not unique. (${paths.join(", ")}).`); } catch (e) { console.log(e); throw e; } } } Object.freeze(common); return common; }51:Tb09,loc = { function parseYaml(text, target) { let lines = text.split("\n"); lines = lines.filter(l => { let trimmed = l.trim(); if (trimmed.length == 0 || trimmed.startsWith("#")) return false; return /^[ ][^ ]+/.test(l); }); for (let line of lines) { let match = /^[\s]*(?[^:]+)\:(((?[\d]+)[\s]+)|([\s]*))"(?.*)"/.exec(line); if (!match) throw line; target[match.groups.key] ??= []; target[match.groups.key][match.groups.digit ?? 0] = match.groups.value; } return target; } let locfiles = gameDataZip.filenames.filter(z => z.startsWith("localization") && z.endsWith(".yml") && z.includes("l_english")); let rawresult = {}; for (let filepath of locfiles) { let text = await gameDataZip.file(filepath).text(); let lines = text.split("\n"); lines = lines.filter(l => { let trimmed = l.trim(); if (trimmed.length == 0 || trimmed.startsWith("#")) return false; return /^[ ][^ ]+/.test(l); }); for (let line of lines) { let match = /^[\s]*(?[^:]+)\:(((?[\d]+)[\s]+)|([\s]*))"(?.*)"/.exec(line); if (!match) throw line; rawresult[match.groups.key] ??= []; rawresult[match.groups.key][match.groups.digit ?? 0] = match.groups.value; } } let dict = new Map(); // Arrays to strings for (let [key, values] of Object.entries(rawresult)) { dict.set(key, values.filter(v => v).pop()); } // Template replacements for (let [key, text] of dict.entries()) { if (!text) continue; let loopCount = 0; while (loopCount < 10) { loopCount++; let match = /(?