25:["$","title",null,{"children":"Victoria 3 resource map v2.5 SVG | mheard03 | Observable"}] 49:T53f,{ let mapSvg = worldMap.querySelector("svg"); applyMapStyles(mapSvg); attachNonZoomEvents(mapSvg); let decentralized, clipClone, shadeClone; worldMap.ready.then(() => { let centralized = mapSvg.querySelector('g.layer.centralization path[data-centralization="false"]'); if (centralized) centralized.remove(); decentralized = mapSvg.querySelector('g.layer.centralization path.centralization'); if (decentralized) { clipClone = mapSvg.querySelector('#decentralization-path'); if (clipClone) return; clipClone = decentralized.cloneNode(); [...clipClone.getAttributeNames()].filter(n => n != "d").forEach(n => clipClone.removeAttribute(n)); clipClone.setAttribute("id", "decentralization-path"); let dcp = mapSvg.querySelector("#decentralization-clip"); dcp.append(clipClone); shadeClone = decentralized.cloneNode(); shadeClone.classList.add("shade"); mapSvg.querySelector('g.layer.states').before(svg`${shadeClone}`); decentralized.classList.add("hue"); } }); worldMap.done.then(() => { let decentralizedPath = decentralized.getAttribute("d"); clipClone.setAttribute("d", decentralizedPath); shadeClone.setAttribute("d", decentralizedPath); }); return worldMap; }4a:Tdde,function applyMapStyles(mapSvg) { const defs = svg` `; const style = svg` `; let dcp = mapSvg.querySelector("#decentralization-path"); if (dcp) dcp = dcp.cloneNode(); const selector = [defs, style].map(e => `svg > #${e.id}`).join(", "); [...mapSvg.querySelectorAll(selector)].forEach(e => e.remove()); mapSvg.prepend(defs, style); if (dcp) mapSvg.querySelector("#decentralization-clip").append(dcp); }4b:T422,getZoomStyleParams = { let _map; let minScale = -1, maxScale = -1; let elements; function getMapStylingObjects(map, zoom) { let scaleExtent = zoom.scaleExtent(); if (elements && map == _map && minScale == scaleExtent[0] && maxScale == scaleExtent[1]) return elements; [ minScale, maxScale ] = scaleExtent; elements = { svg: map.querySelector("svg"), stripePattern: map.querySelector("defs #stripe-pattern"), scales: { stripe: d3.scaleLinear().domain([minScale, maxScale]).range([0.75, 0.35]), centralizationStroke: d3.scaleLinear().domain([minScale, maxScale]).range([16, 8]).clamp(true), stripeStroke: d3.scaleLinear().domain([minScale, maxScale]).range([7, 4]).clamp(true), regionStroke: d3.scaleLinear().domain([minScale, 6, maxScale]).range([0.25, 0.25, 0.5]).clamp(true), stateStroke: d3.scaleLinear().domain([minScale, 3, 9, maxScale]).range([0, 0.25, 0.25, 0.5]).clamp(true) } } _map = map; return elements; } return getMapStylingObjects; }4c:T469,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 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 } }; rollupFields.land.getLookupId = (p => "land"); rollupFields.centralization.getLookupId = (p => !!countries[p.country].isDecentralized); for (let rollupField of Object.values(rollupFields)) { rollupField.getLookupId ??= (p => p[rollupField.singular]); } return rollupFields; }4d:T81b,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") { if (!goodId) return; debugger; 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; }4e:T97a,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; } } } resourceLevels[""] = { goodId: "", category: "", buildings: [], states: {}, regions: {}, isBlank: true }; /* // 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"); }4f: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"); }50:T624,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); }51:T852,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: {}, is_coastal: !!stateDef.naval_exit_id }; // 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); } // region_groups for (let state of Object.values(states)) { state.big_regions = region_groups.findAll(state.region); state.big_region = region_groups.find(state.region); } return states; }52:T114a,region_groups = { const idFromKey = (key) => (key.startsWith("state_is_in_")) ? key.replace("state_is_in_", "") : undefined; // Create a regionGroup for each "state_is_in_" geography trigger let regionGroups = {}; for (let [key, value] of Object.entries(common.scripted_triggers)) { const id = idFromKey(key); if (!id) continue; const name = id.split("_").map(t => t[0].toUpperCase() + t.slice(1)).join(" "); const regionGroup = { id, name, regions: [] }; const regionList = value.OR?.region; if (regionList && Array.isArray(regionList)) { regionGroup.regions.push(...regionList.map(r => r.split(":").pop())); } for (let key of Object.keys(value.OR)) { const childRegion = regionGroups[idFromKey(key)]; if (!childRegion) continue; regionGroup.regions.push(...childRegion.regions); } if (regionGroup.regions.length) { regionGroups[id] = regionGroup; } } // Create a regionGroup for each orphaned region const groupedRegions = Object.values(regionGroups).flatMap(r => r.regions); const orphanRegions = _.difference(Object.keys(regionCentroids), groupedRegions); for (let regionId of orphanRegions) { regionGroups[regionId] = { id: regionId.replace("region_", ""), name: loc.get(regionId), regions: [regionId] } } // Identify ancestors let regionGroupsList = Object.values(regionGroups); for (let regionGroup of regionGroupsList) { const ancestors = []; for (let other of regionGroupsList.filter(r => r != regionGroup)) { if (_.intersection(other.regions, regionGroup.regions).length == regionGroup.regions.length) { ancestors.push(other.id); } } if (ancestors.length) regionGroup.ancestors = ancestors; } // Link parents and children while (regionGroupsList.some(r => r.ancestors?.length == 1)) { let singleAncestorRegions = regionGroupsList.filter(r => r.ancestors?.length == 1); let multiAncestorRegions = regionGroupsList.filter(r => r.ancestors?.length > 1); for (let regionGroup of singleAncestorRegions) { const parentId = regionGroup.ancestors[0]; regionGroup.parent = parentId; const parent = regionGroups[parentId]; parent.children ??= []; parent.children.push(regionGroup.id); multiAncestorRegions.forEach(r => r.ancestors = r.ancestors.filter(a => a != regionGroup.id)); delete regionGroup.ancestors; } } // Sort for (let regionGroup of regionGroupsList) { const centroids = regionGroup.regions.map(r => regionCentroids[r]); const centroid = [_.meanBy(centroids, 0), _.meanBy(centroids, 1)]; regionGroup.sortNum = 1.5 * centroid[0] + centroid[1]; } for (let regionGroup of regionGroupsList.filter(r => r.children)) { const bestChildSortNum = _.min(regionGroup.children.map(c => regionGroups[c].sortNum)); regionGroup.sortNum = _.mean([regionGroup.sortNum, bestChildSortNum]); } regionGroupsList = _.sortBy(regionGroupsList, r => r.sortNum); function getSequence(region) { if (!region.children) return [region]; let childSequences = region.children.map(c => getSequence(regionGroups[c])); return [region, ...childSequences.flat()]; } regionGroupsList = regionGroupsList.filter(r => !r.parent).map(r => getSequence(r)).flat(); // Misc for (let regionGroup of regionGroupsList) { // Assign depth regionGroup.depth = 0; let parent = regionGroup.parent; while (parent) { regionGroup.depth++; parent = regionGroups[parent].parent; } // children vs. descendants if (regionGroup.children) { regionGroup.allRegions = [...regionGroup.regions]; const childRegions = regionGroup.children.flatMap(c => regionGroups[c].regions); regionGroup.regions = _.difference(regionGroup.regions, childRegions); } // Cleanup regionGroupsList.forEach(r => delete r.sortNum); } const region_groups = Object.fromEntries(regionGroupsList.map(r => [r.id, r])); const findAll = function(region) { region = region._id ?? region; return regionGroupsList.filter(r => (r.allRegions ?? r.regions).includes(region._id ?? region)); } region_groups.findAll = function(region) { return findAll(region).map(r => r.id); } region_groups.find = function(region) { return _.maxBy(findAll(region), r => r.depth)?.id; } return region_groups; }53:T1477,common = { let createdNodes = []; let common = {}; 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, filePath); if (makeArray.length) { for (let obj of Object.values(parsed)) { makeArray.forEach(path => coerceToArray(obj, path)); } } if (setIds) setIdsForObjectKeys(parsed); Object.assign(target, parsed); } } function filterSeaRegions(parsed) { let landRegionEntries = Object.entries(parsed).filter(([id, r]) => r.capital_province || r.map_color || r.graphical_culture) return Object.fromEntries(landRegionEntries); } function tagGenericStateTraits(parsed, path) { let filename = path.split("/").pop(); let isGenericFile = filename.toLowerCase().startsWith("00_generic"); Object.values(parsed).forEach(trait => trait.is_generic = isGenericFile); return 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/state_traits", { postProcess: tagGenericStateTraits }) await loadFolder("common/scripted_triggers", { setIds: false }); await loadFolder("common/strategic_regions", { postProcess: filterSeaRegions }); 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); } }); Object.freeze(common); return common; }54: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 = /(?