25:["$","title",null,{"children":"Victoria 3 resource map v2.2 | mheard03 | Observable"}] 49:Tdac,mapSvg = { await mapSvgComponents; let stretchAmount = mapSvgComponents.stretchAmount; let xCoords = [0, mapSvgComponents.width]; let layerDefs = []; let layerRefs = [] for (let mapLayerName of ["land", "states", "countries", "regions"]) { let className = rollupFields[mapLayerName].plural; // viewBox="0 0 ${mapSvgComponents.width} ${mapSvgComponents.height}" preserveAspectRatio="xMidYMid slice layerDefs.push(svg` ${Object.values(mapSvgComponents[mapLayerName])} `); for (let x of xCoords) { layerRefs.push(svg``); } } let mapImage = svg`

${mapImage}

`; }4a:T7a3,mapEvents = { const height = width * repaintedMaps.heightRatio; const root = d3.select(mapSvg) .style("width", `${width}px`) .style("height", `${height}px`); const svgNode = root.select("svg") .style("height", `${height}px`) .style("transform-origin", "0 0"); const tooltip = root.select("#tooltip"); let popper; const stripePattern = root.select("#stripe"); let stripeScale = d3.scaleLinear() .domain([1,8]) .range([0.75, Math.min(0.75, 0.35)]); let stripeStrokeWidth = d3.scaleLinear() .domain([1,8]) .range([7, 4]); root.call(d3.zoom() .extent([[0, 0], [width, height]]) .scaleExtent([1, 8]) .translateExtent([[-Infinity, 0], [Infinity, height]]) .on("zoom", onZoom)); root.selectAll(".states path.state") .on("mouseover", onMouseover); function onZoom({transform: d3transform}) { let transform = transformParser.parse(`translate(${d3transform.x}px, ${d3transform.y}px) scale(${d3transform.k})`); let scaledMapWidth = width * transform.scale; while (transform.translate[0] > 0) { // Left edge is exposed transform.translate[0] -= scaledMapWidth; } while (transform.translate[0] < -scaledMapWidth) { // Right edge is exposed transform.translate[0] += scaledMapWidth; } svgNode.style("transform", transformParser.stringify(transform)); stripePattern.attr("patternTransform", `scale(${stripeScale(transform.scale)})`); svgNode.style('--stripeStrokeWidth', `${Math.round(stripeStrokeWidth(transform.scale))}px`); } function onMouseover(e) { let target = e.target; if (!target.classList.contains("state")) return; let stateId = target.dataset.stateId; let tooltipContent = `${Object.keys(states[stateId].resources)}`; tooltip.html(tooltipContent); } return "Zoom and tooltip event handlers, IGNORE ME"; }4b:T655,mapSvgComponents = { let stretchAmount = 40; let { width, height } = repaintedMaps; let entityCount = Object.keys(states).concat(Object.keys(regions)).concat(Object.keys(countries)).length; let tracker = ReadyTracker.createOrReset("Generating SVG", { trackProgress: true, progressMax: entityCount }); let results = { width, height, stretchAmount }; await tracker.setProgressCount(0); for (let mapLayerName of mapLayerNames) { let stretched = stretchCanvasEdges(repaintedMaps[mapLayerName].ctx, stretchAmount); let imageData = stretched.ctx.getImageData(0, 0, stretched.width, height); let markup = await Dotrace.toSVG(imageData.data, stretched.width, height); let img = svg`${markup}`; let singular = rollupFields[mapLayerName].singular let dataAttrName = _.camelCase([singular, "id"]); let paths = [...img.querySelectorAll("path")]; let entityPaths = {}; if (mapLayerName == "land") { entityPaths.land = paths[0]; } else { for (let path of paths) { let colorNum = ColorNum.fromHex(path.getAttribute("fill")); path.removeAttribute("fill"); let entityId = colorSwap.get(colorNum)[singular].id; path.classList.add(singular); path.dataset[dataAttrName] = entityId; entityPaths[entityId] = path; await tracker.incrementProgressCount(); } } results[mapLayerName] = entityPaths; } for (let country of Object.values(countries).filter(c => c.isDecentralized)) { results.countries[country.id].classList.add("decentralized"); } tracker.done(); return results }4c:T6da,repaintedMaps = { let blockSize = 2; let [width, height] = [worldMapImage.width, worldMapImage.height].map(c => Math.round(c / blockSize)); let heightRatio = height / width; // Find a chunk size that's less than 500, an even multiple of blockSize, and has minimal overhang on the y axis. let chunkSize = 10000; for (let i = 0; i < 20; i++) { if (chunkSize <= 500) break; let yBlocks = Math.ceil(worldMapImage.height / blockSize); chunkSize = blockSize * Math.ceil(yBlocks / i); } let chunkCount = Math.ceil(worldMapImage.width / chunkSize) * Math.ceil(worldMapImage.height / chunkSize); let results = { width, height, heightRatio }; let tracker = ReadyTracker.createOrReset("repaintedMaps", { trackProgress: true, progressMax: chunkCount, label: "Resizing game map" }); for (let mapLayerName of mapLayerNames) { let canvas = DOM.canvas(width, height); let ctx = canvas.getContext('2d', { willReadFrequently: true }); let imageData = ctx.getImageData(0, 0, width, height); results[mapLayerName] = { width, height, canvas, ctx, imageData }; } for (let x = 0; x < width; x += chunkSize / blockSize) { let sx = x * blockSize; for (let y = 0; y < height; y += chunkSize / blockSize) { let sy = y * blockSize; let imageData = worldMapImage.ctx.getImageData(sx, sy, chunkSize, chunkSize); let repaintedRegions = await repaintAndShrinkMapRegion(imageData, blockSize); for (let mapLayerName of mapLayerNames) { let repaintedRegionData = repaintedRegions[mapLayerName]; results[mapLayerName].ctx.putImageData(repaintedRegionData, x, y); } await tracker.incrementProgressCount(); } } tracker.done(); return results; }4d:T670,async function repaintAndShrinkMapRegion(sourceImageData, blockSize) { let srcPixelIO = new PixelIO(sourceImageData); let [width, height] = [srcPixelIO.width, srcPixelIO.height].map(c => Math.round(c / blockSize)); let resultBuilders = []; let results = {}; let white = ColorNum.fromHex("#ffffff"); for (let [layerName, rollupInfo] of Object.entries(rollupFields)) { let canvas = DOM.canvas(width, height); let ctx = canvas.getContext('2d'); let imageData = ctx.getImageData(0, 0, width, height); let pixelIO = new PixelIO(imageData); let propName = rollupInfo.singular; resultBuilders.push({ pixelIO, imageData, mapPixel: function (x, y, srcColorNum) { let provinceColor = colorSwap.get(srcColorNum); if (!provinceColor) return; let newColorNum = provinceColor[propName].colorNum; if (!newColorNum) return; pixelIO.setColorNum(x, y, newColorNum); } }); results[layerName] = imageData; } let loopCount = 1; let pauseIncrement = 333; let lastPause = performance.now(); for (let dx = 0; dx < width; dx++) { let sx = dx * blockSize; for (let dy = 0; dy < height; dy++) { let sy = dy * blockSize; let sourceColorNum = srcPixelIO.getDominantColorNum(sx, sy, blockSize); resultBuilders.forEach(b => b.mapPixel(dx, dy, sourceColorNum)); if (loopCount++ % 100 == 0) { let timeSinceLastPause = performance.now() - lastPause; if (timeSinceLastPause >= pauseIncrement) await new Promise(r => requestAnimationFrame(r)); } } } return results; }4e:T735,getColorScale = { const yellow = colorScaleBasis.yellow; const green = colorScaleBasis.green; const maxC = _.min(Object.values(colorScaleBasis).map(c => c.get("c"))); const hScale = d3.scaleLinear().domain([0,1]).range([yellow.get("h"), green.get("h")]); const jScale = d3.scaleLinear().domain([0,1]).range([yellow.get("j"), green.get("j")]); const intensityScale = d3.scaleLinear().domain([0,1]).range([0.01, 1]); function getColorScale(goodId, geo = "states") { let levels = resourceLevels[goodId]; let quantities = Object.values(levels[geo]); let maxTotal = _.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))); let cScale = d3.scaleLinear().domain([-maxTotal, maxTotal]).range([0, maxC]); return function(discovered, undiscovered) { if (discovered == 0 && undiscovered == 0) return "#ffffff"; let totalPresent = (discovered + undiscovered); let pctDiscovered = discovered / totalPresent; let maxColorCoords = [jScale(pctDiscovered), maxC, hScale(pctDiscovered)]; let minColorCoords = [100, 0, hScale(pctDiscovered)]; let intensity = intensityScale(totalPresent / maxTotal); let c1 = maxColorCoords.map(c => c * intensity); let c2 = minColorCoords.map(c => c * (1 - intensity)); let coords = c1.map((c,i) => c + c2[i]); // let coords = maxColorCoords.map(v => v * intensity); // coords[0] += (100 * (1 - intensity)); // coords[2] = maxColorCoords[2]; return new Color("jch", coords).toGamut("srgb").to("srgb").toString({ format: "hex" }); } } return getColorScale; }4f: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"); }50: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"); }51: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); }52:T73d,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, 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; }53: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; }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 = /(?