25:["$","title",null,{"children":"Victoria 3 resource map v2.3 | mheard03 | Observable"}] 49:Te57,mapSvg = { await mapSvgComponentsGenerated; let stretchAmount = mapSvgComponentsGenerated.stretchAmount; let xCoords = [0, mapSvgComponentsGenerated.width]; let layers = []; for (let mapLayerName of ["land", "countries", "states", "regions"]) { let className = rollupFields[mapLayerName].plural; let layer = svg``; for (let x of xCoords) { let svgElements = Object.values(mapSvgComponentsGenerated[mapLayerName]).map(e => e.cloneNode(true)); let tile = svg` ${svgElements} `; layer.append(tile); } layers.push(layer); } let mapImage = svg`

${mapImage}

`; }4a:Tf4d,selectedState = { let yieldNext; let generator = Generators.observe(next => { yieldNext = next; }) 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 minZoom = 1; const maxZoom = 8; const stripePattern = root.select("#stripe"); let stripeScale = d3.scaleLinear().domain([minZoom, maxZoom]).range([0.75, Math.min(0.75, 0.35)]); let stripeStrokeWidth = d3.scaleLinear().domain([minZoom, maxZoom]).range([7, 4]); let regionStrokeWidth = d3.scaleLinear().domain([minZoom, (minZoom + maxZoom) / 3, maxZoom]).range([0.25, 0.25, 0.5]).clamp(true); let stateStrokeWidth = d3.scaleLinear().domain([minZoom, (minZoom + maxZoom) / 2, maxZoom]).range([0, 0, 0.25]).clamp(true); root.call(d3.zoom() .extent([[0, 0], [width, height]]) .scaleExtent([minZoom, maxZoom]) .translateExtent([[-Infinity, 0], [Infinity, height]]) .on("zoom", onZoom)); svgNode.selectAll(".states .state") .on("mouseover", onmouseover) .on("mouseout", onmouseout) .on("click", onclick); const round25 = (n) => Math.round(n*4)/4; 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', `${round25(stripeStrokeWidth(transform.scale))}px`); svgNode.style('--regionStrokeWidth', `${regionStrokeWidth(transform.scale)}px`); svgNode.style('--stateStrokeWidth', `${stateStrokeWidth(transform.scale)}px`); } function getPathsByEntityId(elementOrId) { let id = elementOrId; if (elementOrId.node instanceof Function) elementOrId = elementOrId.node(); if (elementOrId instanceof Element) id = elementOrId.dataset.id; return mapSvgComponents.get(id) || []; } function updateHoverClass() { // Elements matching .hover (some of which may be bogus) let hoverClassElements = [...svgNode.node().querySelectorAll(".hover")]; // Elements with the same data-id as the current :hover element (all of which need .hover) let mouseHoverElements = [...svgNode.node().querySelectorAll(".state:hover")]; mouseHoverElements = mouseHoverElements.flatMap(e => getPathsByEntityId(e)); // remove bogus .hover from elements that shouldn't have it for (let el of _.difference(hoverClassElements, mouseHoverElements)) { el.classList.remove("hover"); } // add .hover to elements that need it, and yeet them to the end of their parent so strokes aren't covered let didYeet = false; for (let el of mouseHoverElements) { el.classList.add("hover"); if (el.nextElementSibling) { didYeet = true; el.parentElement.append(el); } } if (didYeet) setTimeout(updateHoverClass, 10); } function onclick(e) { let target = e.target; if (!target.classList.contains("state")) return; yieldNext(mapSvgComponents.get(target)); } function onmouseover(e) { requestAnimationFrame(updateHoverClass); } function onmouseout(e) { requestAnimationFrame(updateHoverClass); } // return "Zoom and tooltip event handlers, IGNORE ME"; yieldNext(undefined); return generator; }4b:T61d,mapSvgComponentsGenerated = { 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 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.id = 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:T61a,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 }, regions: { zIndex: 1, singular: "region", plural: "regions", lookup: regions }, states: { zIndex: 2, singular: "state", plural: "states", lookup: states }, 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; }4f: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; }50: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"); }51: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"); }52: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); }53:T7f6,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, provinces: new Set(stateDef.provinces.map(p => fixPdxColor(p))), countries: [], countryProvinces: {}, 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()]; for (let { country: nsCountryId, owned_provinces } of stateDef.create_state) { owned_provinces = owned_provinces.map(c => fixPdxColor(c)); let countryId = nsCountryId.split(":").pop(); state.provinces.add(...owned_provinces); state.countries.push(countryId); state.countryProvinces[countryId] = owned_provinces.map(c => fixPdxColor(c)); state.colorNum = ColorNum.fromPdx(owned_provinces[0]); } } for (let state of Object.values(states)) { state.provinces = [...state.provinces]; } // 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; }54:T15ad,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"] }); { let text = await gameDataZip.file("map_data/province_terrains.txt").text(); text = text.replace(/^[\s]*/, ""); common.map_data.province_terrains = jomini.parseText2(text, false); } 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; }55: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 = /(?