25:["$","title",null,{"children":"Victoria 3 resource glpk v5.81 country selection | mheard03 | Observable"}] 49:T733,viewof selectedCountry = { invalidation.then(() => updateOptGroups(this)); let eligibleCountries = Object.values(countries) .filter(c => selectedCountryTypes.length == 0 || selectedCountryTypes.includes(c.type)) .filter(c => selectedCountryTiers.length == 0 || selectedCountryTiers.map(t => t.id).includes(c.tier)); eligibleCountries.unshift(null); let countryLabels = Object.values(eligibleCountries).map(c => { if (c === null) return ["None", c]; let ctLabel = (selectedCountryTypes.length == 1 || c.type == "historical") ? "" : ` (${c.type})`; return [c.name + ctLabel, c] }); function updateOptGroups(form) { if (!form) return; let selectedValue = form.value ?? null; let select = form.querySelector("select"); let options = [...select.querySelectorAll("option")]; [...select.querySelectorAll("optgroup")].forEach(g => g.remove()); if (options.length == 0) { return; } if (selectedCountryTiers.length == 1 || eligibleCountries.length == 1) { select.append(...options); } else { let optionsByTier = _.groupBy(options, o => eligibleCountries[parseInt(o.value)]?.tier); for (let tierId of Object.keys(optionsByTier)) { if (!countryTiers[tierId]) { select.prepend(...optionsByTier[tierId]); continue; } let optGroup = html``; select.append(optGroup); optGroup.append(...optionsByTier[tierId]); } } select.value = eligibleCountries.indexOf(selectedValue); } let value = this?.value; if (!eligibleCountries.includes(value)) value = undefined; console.log('value', value); let form = Inputs.select(new Map(countryLabels), { label: "Country", value }); updateOptGroups(form); return form; }4a:T8c6,viewof selectedPopLimit = { const getPopCount = (population) => population / popTypes.peasants.individualsPerBuyPackage; let population = 0, min, max, paragraph; if (selectedCountry) { population = selectedCountry.population; min = population * 0.75; max = population * 2; paragraph = `${selectedCountry.name} starts with ~${Math.round(getPopCount(population))} pops.`; } else { let eligibleCountries = Object.values(countries) .filter(c => selectedCountryTypes.length == 0 || selectedCountryTypes.includes(c.type)) .filter(c => selectedCountryTiers.length == 0 || selectedCountryTiers.map(t => t.id).includes(c.tier)); population = d3.median(eligibleCountries.map(c => c.population)); min = _.min(eligibleCountries.map(c => c.population)); max = 1.5 * _.max(eligibleCountries.map(c => c.population)); let ofThis = []; let typeCount = _.uniq(Object.values(countries).map(c => c.type)).length; let tierCount = _.uniq(Object.values(countries).map(c => c.tier)).length; if (selectedCountryTypes.length != 0 && selectedCountryTypes.length != typeCount) ofThis.push("type"); if (selectedCountryTiers.length != 0 && selectedCountryTiers.length != tierCount) ofThis.push("tier"); ofThis = (ofThis.length == 0) ? "" : ` of this ${ofThis.join(" and ")}`; paragraph = `Countries ${ofThis} start with a median of ~${Math.round(getPopCount(population))} pops.` } let popCount = Math.round(getPopCount(population)); min = Math.ceil(getPopCount(min)); max = Math.ceil(getPopCount(max)); let value = popCount; if (this) { let oldValue = this.value; let input = this.querySelector("input"); if (oldValue >= min && oldValue <= max) value = this.value; } let form = Inputs.range([min, max], { step: 1, label: "Pop count", value }); let label = form.querySelector("label"); let afterLabel = form.querySelector("label").nextElementSibling; let result = html`${form}

<${afterLabel.tagName} class="${afterLabel.className}">${paragraph}`; result.querySelector("mark").style.whiteSpace = "nowrap"; return result; }4b:T64e,viewof selectedLawsForm = { let textCounter = 0; let formElements = []; let categories = _.groupBy(laws, "category"); for (let categoryLaws of Object.values(categories)) { let groups = _.groupBy(categoryLaws, "group"); for (let groupLaws of Object.values(groups)) { if (groupLaws.every(g => !g.unlocks)) continue; let availableLaws = Object.values(groupLaws).filter(l => availableInEra(l, selectedEra)); let relevantLaws = availableLaws.filter(l => l.unlocks); let selectOptions = []; let inputOptions = { label: loc.tryGetText(groupLaws[0].group), disabled: !relevantLaws.length }; if (availableLaws.length) { selectOptions = relevantLaws.map(l => { let labelParts = [ [l.unlocks.pms, "PM"], [l.unlocks.buildings, "building"], [l.unlocks.modifiers, "modifier"] ] .filter(([value, label]) => value) .map(([value, label]) => `${value} ${label}${value > 1 ? "s" : ""}`); let parens = ""; if (labelParts.length) parens = ` (${labelParts.join(", ")})`; let label = `${loc.tryGetText(l.id)}${parens}`; return [label, l.id]; }); if (relevantLaws.length < availableLaws.length) { selectOptions.unshift(["Other", ""]); } } // formElements.push({inputOptions, selectOptions}); formElements.push(Inputs.select(new Map(selectOptions), inputOptions)); } } formElements = formElements.map(e => Object.assign(e, { style: '--label-width: 150px; --input-width: 300px' })) return Inputs.form(formElements); }4c:T558,baseGraph = { return; function buildCluster(name, nodes, rank) { // subgraph cluster_${name} dotGraphLines.push(` {`); if (rank) { dotGraphLines.push(` rank=${rank}`); } nodes.forEach(n => dotGraphLines.push(` "${n}"`)); dotGraphLines.push(` }`); } let dotGraphLines = ["digraph g {"]; dotGraphLines.push(" mclimit=3;"); dotGraphLines.push(" rankdir=LR;"); // dotGraphLines.push(" concentrate=true"); dotGraphLines.push(" node[shape=rect];"); let upstreamNodes = links.map(l => l.source).filter(n => n.endsWith("_upstream")); upstreamNodes = _.uniq(upstreamNodes); // buildCluster("upstream", upstreamNodes, "source"); let downstreamNodes = links.map(l => l.target).filter(n => n.endsWith("_downstream")); downstreamNodes = _.uniq(downstreamNodes); // buildCluster("downstream", downstreamNodes, "sink"); let otherNodes = links.flatMap(l => [l.source, l.target]).filter(n => !n.endsWith("stream")); otherNodes = _.uniq(otherNodes); buildCluster("other2", otherNodes); links.forEach(({ source, target, value }) => { if (otherNodes.includes(source) && otherNodes.includes(target)) { dotGraphLines.push(` "${source}" -> "${target}"`); } }); dotGraphLines.push("}"); // return dotGraphLines.join("\n"); return dot`${dotGraphLines.join("\n")}`; }4d:Ta11,processedSolutionRanks = { if (!solutionPmSelections ) return; let pmses = solutionPmSelections; let ruralPmses = pmses.filter(pms => buildings[pms.building].category == "rural"); let ruralOutputs = ruralPmses.flatMap(pms => pms.outputs).filter(o => !hackGoods.includes(o)); function getSupplyChains(pms, chain) { chain ??= [pms]; // let indent = "".padStart(chain.length * 2); // console.log(indent + "getSupplyChains", pms.building, chain); let isRural = ruralPmses.includes(pms) || chain.some(pms => ruralPmses.includes(pms)); let allOutputs = _.uniq(chain.flatMap(a => a.outputs)); let neededInputs = pms.inputs.filter(i => !hackGoods.includes(i) && !allOutputs.includes(i)); // console.log(indent + 'neededInputs', neededInputs); if (neededInputs.length == 0) return [chain]; let suppliers = pmses.filter(pms => chain.head != pms && !allOutputs.includes(pms)) .filter(pms => pms.outputs.some(i => neededInputs.includes(i))) .filter(pms => !chain.includes(pms)); if (isRural) suppliers = suppliers.filter(s => ruralPmses.includes(s)); if (suppliers.length == 0) return [chain]; // console.log(indent + 'suppliers', suppliers); return suppliers.flatMap(s => getSupplyChains(s, [...chain, s])); } let result = { buildings: {}, pmses: {}, goods: Object.fromEntries(availableGoods.map(g => [g, 0])), goodsFull: Object.fromEntries(availableGoods.map(g => [g, []])) } for (let pms of pmses) { result.buildings[pms.building] ??= 0; let chains = getSupplyChains(pms); let longestChain = Math.max(...chains.map(c => c.length)); result.buildings[pms.building] = Math.max(result.buildings[pms.building] ?? 0, longestChain); result.pmses[pms.id] = Math.max(result.pmses[pms.id] ?? 0, longestChain); // TODO?: maybe find the point at which _most_ has been produced? if (!buildings[pms.building].is_subsistence) { pms.outputs.forEach(o => result.goods[o] = Math.max(result.goods[o] ?? 0, result.pmses[pms.id])); pms.outputs.forEach(o => result.goodsFull[o].push(..._.uniq(chains.map(c => c.length)))); } } result.buildings = sortObjectBy(result.buildings, e => e); result.pmses = sortObjectBy(result.pmses, e => e); result.goods = Object.fromEntries(_.sortBy(Object.entries(result.goods), [1, 0])); result.goodsFull = Object.fromEntries(_.sortBy(Object.entries(result.goodsFull), 0)); Object.keys(result.goodsFull).forEach(g => result.goodsFull[g] = _.sortBy(_.uniq(result.goodsFull[g]))); return result; }4e:T578,links = { let links = {}; for (let pms of solutionPmSelections) { for (let [input, amount] of Object.entries(pms.combinedPm.inputs)) { if (hackGoods.includes(input)) continue; let inputRank = processedSolutionRanks.goods[input]; for (let output of pms.outputs) { if (hackGoods.includes(output)) continue; let outputRank = processedSolutionRanks.goods[output]; let isUpstream = (inputRank > outputRank); let linkSource = isUpstream ? `${input}_upstream` : input; links[linkSource] ??= {}; links[linkSource][output] ??= 0; links[linkSource][output] += amount; if (isUpstream) { let downstreamTarget = `${input}_downstream`; links[input] ??= {}; links[input][downstreamTarget] ??= 0; links[input][downstreamTarget] += amount; } } } } let flatLinks = []; for (let [source, targets] of Object.entries(links)) { for (let [target, value] of Object.entries(targets)) { flatLinks.push({source, target, value}); } } return _.sortBy(flatLinks, ["source", "target"]); /* let toMerge = _.groupBy(flatLinks, l => `${l.source}|${l.target}`); let merged = Object.values(toMerge).map(m => m.reduce((sum, link) => ({ source: link.source, target: link.target, amount: (sum.amount ?? 0) + link.amount return {toMerge, merged}; */ }4f:T1ccb,"Solution chains" /* { function getChainProduction(methods, goodsToConsider) { let combinedPm = methods.reduce((combined, pm) => combined.combine(pm), new ProductionMethod()); let net = Object.fromEntries(goodsToConsider.map(g => [g, 0])); Object.entries(combinedPm.inputs) .filter(e => goodsToConsider.includes(e[0])) .forEach(([good, amount]) => net[good] -= amount); Object.entries(combinedPm.outputs) .filter(e => goodsToConsider.includes(e[0])) .forEach(([good, amount]) => net[good] += amount); Object.keys(net).forEach(good => net[good] = (Math.abs(net[good]) < 0.000001) ? 0 : net[good]); let deficits = Object.entries(net).filter(e => e[1] < 0) return { net, deficits: Object.fromEntries(deficits), deficitGoodsKey: _.sortBy(deficits.map(d => d[0])).join("|"), deficitCount: deficits.length, deficitVolume: deficits.map(d => d[1]).reduce((sum, d) => sum + d, 0), maxDeficitVolume: Math.min(0, ...deficits.map(d => d[1])) } } function getNextLinkOptions(chain, pmses, goodsToConsider, peekOnly = false) { let chainPmses = chain.map(c => c.pms); let chainMethods = chainPmses.map(pms => pms[solverOptions.combinedPmField]); let productionSoFar = getChainProduction(chainMethods, goodsToConsider); let candidates = pmses.filter(pms => !chainPmses.includes(pms)) .map(pms => ({ pms, stats: getChainProduction([pms[solverOptions.combinedPmField], ...chainMethods], goodsToConsider) })); // Return early if there are no candidates (implies we're done) if (candidates.length == 0) return []; // Return early if there's only one candidate left (also implies we're done) if (candidates.length == 1) return [candidates]; // If any candidates have all their needs met, return them all as a single option let readyCandidates = candidates.filter(c => c.stats.deficitVolume == 0); if (readyCandidates.length) return [readyCandidates]; // If every remaining candidate is waiting for the same stuff, return them all as a single option. if (_.uniq(candidates.map(c => c.stats.deficitGoodsKey)).length == 1) return [candidates]; if (peekOnly) return []; // No candidates have their needs met. :-( // Return gkGroups that can unlock pmses, if any let gkGroups = Object.values(_.groupBy(candidates, c => c.stats.deficitGoodsKey)); let peekResults = gkGroups.map(gkGroup => ({ gkGroup, unlocks: getNextLinkOptions([...chain, ...gkGroup], pmses, goodsToConsider, true) })); let maxUnlocks = Math.max(0, ...peekResults.map(pr => pr.unlocks.length)); if (maxUnlocks > 0) { let promisingGroups = peekResults.filter(pr => pr.unlocks.length == maxUnlocks).flatMap(pr => pr.gkGroup); return promisingGroups.map(pg => [pg]); } // If not... just try some stuff let promisingCandidates = []; let minDeficitCount = Math.min(...candidates.map(c => c.stats.deficitCount)); promisingCandidates.push(...candidates.filter(c => c.stats.deficitCount == minDeficitCount)) gkGroups = _.sortBy(gkGroups, a => a.length); promisingCandidates.push(...gkGroups[0]); promisingCandidates.push(...gkGroups[gkGroups.length - 1]); promisingCandidates = _.uniq(promisingCandidates); promisingCandidates = _.uniq(promisingCandidates); return promisingCandidates.map(pc => [pc]); } let sequences = []; let loopCount = 0; function buildChains(pmses, goodsToConsider, chains) { let stack = (chains ?? []).map(c => c); if (!stack.length) stack = getNextLinkOptions([], pmses, goodsToConsider); chains = []; try { while (stack.length && loopCount < 5000) { loopCount++; let chain = stack.pop(); let nextLinkOptions = getNextLinkOptions(chain, pmses, goodsToConsider); if (nextLinkOptions.length == 0) { chains.push(chain); sequences = _.uniq(sequences); } else { for (let option of nextLinkOptions) { sequences.push(..._.uniq(option.map(c => c.stats.deficitGoodsKey))); stack.push([...chain, ...option]); } } } } catch (e) { console.log(e); throw e; } return { fail: "fail", chains, stack, sequences }; } let ruralPmSelections = solutionPmSelections.filter(pms => buildings[pms.building].category == "rural"); let ruralGoods = ruralPmSelections.flatMap(pms => pms.outputs).filter(o => !hackGoods.includes(o)); let nonRuralPmSelections = solutionPmSelections.filter(pms => buildings[pms.building].category != "rural"); let chains = buildChains(ruralPmSelections, ruralGoods).chains; let ruralChainLength = chains[0].length // return chains.map(chain => chain.map(c => solutionPmSelections.indexOf(c.pms))); chains = buildChains(nonRuralPmSelections, availableGoods, chains); let getChainIndices = (c) => { c = (c.length > ruralChainLength) ? c.slice(ruralChainLength) : c; return c.map(l => solutionPmSelections.indexOf(l.pms)) }; if (chains.stack) { return { chains: chains.chains.map(c => getChainIndices(c)), stack: chains.stack.map(c => getChainIndices(c)), sequences: chains.sequences } } return chains.map(c => getChainIndices(c)); // console.log({ loopCount, chains: chains.map(c => getChainIndices(c)), stack: stack.map(c => getChainIndices(c)), chain: getChainIndices(chain), nextLinkOptions, }); return chains; // return chains.map(chain => chain.map(c => solutionPmSelections.indexOf(c.pms))); return chains; /* for (let pmsSet of [ruralPmSelections, solutionPmSelections]) { let goodsToConsider = pmsSet.flatMap(pms => pms.outputs).filter(o => !hackGoods.includes(o)); let } let set1 = getNextLinkOptions([], ruralPmses, ruralOutputs); let set2 = getNextLinkOptions(set1[0], ruralPmses, ruralOutputs); return [...set1, ...set2] /* function getNextLinkOptions(chain, pmses, goodsToConsider) { let net = {}; } let ruralPmses = solutionPmSelections.filter(pms => buildings[pms.building].category == "rural"); let ruralOutputs = ruralPmses.flatMap(pms => pms.outputs).filter(o => !hackGoods.includes(o)); function getSupplyChains(pms, chain) { chain ??= [pms]; // let indent = "".padStart(chain.length * 2); // console.log(indent + "getSupplyChains", pms.building, chain); let isRural = ruralPmses.includes(pms) || chain.some(pms => ruralPmses.includes(pms)); let allOutputs = _.uniq(chain.flatMap(a => a.outputs)); let neededInputs = pms.inputs.filter(i => !hackGoods.includes(i) && !allOutputs.includes(i)); // console.log(indent + 'neededInputs', neededInputs); if (neededInputs.length == 0) return [chain]; let suppliers = solutionPmSelections.filter(pms => chain.head != pms && !allOutputs.includes(pms)) .filter(pms => pms.outputs.some(i => neededInputs.includes(i))) .filter(pms => !chain.includes(pms)); if (isRural) suppliers = suppliers.filter(s => ruralPmses.includes(s)); if (suppliers.length == 0) return [chain]; // console.log(indent + 'suppliers', suppliers); return suppliers.flatMap(s => getSupplyChains(s, [...chain, s])); } let goodsRanks = {}; for (let pms of solutionPmSelections) { } } */ 50:T56e,"rankSolution" /* yield undefined; if (pmsRankingProblem) { let solverInstance = await solver; try { console.log("solving"); yield "Solving..."; let solution = await solverInstance.solve(problem); console.log(solution); yield solution; } catch (e) { yield "It broke."; console.log(e); throw e; } finally { // solverInstance.terminate(); } } } /* try { let result = await solverInstance.solve(pmsRankingProblem); return result; } catch (e) { window.pmsRankingProblem = pmsRankingProblem; console.log(e, solverInstance, pmsRankingProblem); throw e; } } /* rankSolution = { yield undefined; if (solverOptions.solverEnabled) { yield "Restarting"; let timeRemaining = solverOptions.timeout; try { let solverInstance = await solver; let rankSolution = undefined; solverInstance.solve(pmsRankingProblem).then(r => rankSolution = r); while (!rankSolution) { yield Promises.tick(100).then(() => { timeRemaining -= 0.1; return `Running... ${Math.ceil(timeRemaining)}`; }); } yield rankSolution; } catch (e) { yield "Error"; console.log(e, pmsRankingProblem); throw e; } } else { yield "Solver disabled" } } */51:T15aa,pmsRankingProblem = { return "potato" if (!allocatedSolutionPmSelections) return; let usedGoods = Object.values(solutionGoods).filter(g => g.tags.includes("rural")).map(g => g.id); //.f Object.keys(solutionGoods); let _allocatedSolutionPmSelections = allocatedSolutionPmSelections.filter(pms => usedGoods.includes(pms.output)); let slotCount = _allocatedSolutionPmSelections.length; let ruralCount = Object.values(_allocatedSolutionPmSelections).filter(pms => buildings[pms.building].category == "rural").length; let allSlots = d3.range(0, slotCount); let ruralSlots = d3.range(0, ruralCount); let nonRuralSlots = d3.range(ruralCount, slotCount); function suffix(name, i) { return `${name}_${i}`; } function setVar(vars, name, coef, type) { let varObj = vars.find(v => v.name == name); if (varObj) { varObj.coef += coef; if (type) { if (varObj.type && type !== varObj.type) throw "whoopsie"; varObj.type ??= type; } } else { varObj = { name, coef }; if (type) varObj.type = type; vars.push(varObj); } } /* Subject to */ let stGlobals = []; let stPmsSlots = []; let stDeficitIndicatorsRural = {}; let stDeficitIndicatorsNonRural = {}; let stProduction = {}; // "constant" variable stGlobals.push({ name: "var_constant", vars: { name: "constant", coef: 1 }, bnds: { type: glpk.GLP_FX, lb: 1 } }); // Every slot must be used exactly once let slotVars = allSlots.map(s => ({ name: suffix("slot", s), coef: 1, type: "binary" })); stGlobals.push({ name: "use_every_slot", vars: slotVars, bnds: { type: glpk.GLP_FX, lb: allSlots.length } }); for (let slotVar of slotVars) { stGlobals.push({ name: `use_${slotVar.name}_once`, vars: slotVar, bnds: { type: glpk.GLP_FX, lb: 1 } }); } // Each pms must be used exactly once for (let pms of _allocatedSolutionPmSelections) { stPmsSlots.push({ name: pms.id, vars: allSlots.map(s => ({ name: suffix(pms.id, s), coef: 1, type: "binary" })), bnds: { type: glpk.GLP_FX, lb: 1 } }); } // Deficit indicator for each good let deficitParams = [ { goods: Object.values(solutionGoods).filter(g => g.tags.includes("rural")).map(g => g.id), slots: allSlots, output: stDeficitIndicatorsRural }, { goods: Object.keys(solutionGoods), slots: nonRuralSlots, output: stDeficitIndicatorsNonRural } ]; for (let { goods, slots, output } of deficitParams) { for (let goodId of usedGoods) { output[goodId] = []; for (let slotNum of slots) { let deficitSlotVars = []; setVar(deficitSlotVars, "constant", -1); setVar(deficitSlotVars, suffix("deficit_" + goodId, slotNum), 1, "binary"); for (let i = 0; i <= slotNum; i++) { setVar(deficitSlotVars, suffix(goodId, i), 1); } output[goodId].push({ name: suffix("has_deficit_" + goodId, slotNum), vars: deficitSlotVars, bnds: { type: glpk.GLP_UP, ub: -0.000000000000001 } }); } } } // Contribution to available goods by each pms in each slot for (let pms of _allocatedSolutionPmSelections) { stProduction[pms.id] = []; let isRural = buildings[pms.building].category == "rural"; let slots = isRural ? ruralSlots : nonRuralSlots; // Goods-in-slots let combinedPm = pms.combinedPm; for (let slotNum of slots) { let pmsSlotVars = []; setVar(pmsSlotVars, suffix(pms.id, slotNum), 1, "binary"); setVar(pmsSlotVars, suffix("slot", slotNum), 1, "binary"); for (let goodId of combinedPm.nonZeroGoods.filter(g => usedGoods.includes(g))) { let amount = (combinedPm.outputs[goodId] ?? 0) - (combinedPm.inputs[goodId] ?? 0); if (amount == 0) continue; for (let i of allSlots.filter(s => s >= slotNum)) { setVar(pmsSlotVars, suffix(goodId, i), amount); } } stProduction[pms.id].push({ name: suffix(pms.id + " in slot", slotNum), vars: pmsSlotVars, bnds: { type: glpk.GLP_LO, lb: 0 } }); } } let subjectTo = [ // ...stGlobals, // ...stPmsSlots, ...Object.values(stProduction).flat(), ...Object.values(stDeficitIndicatorsRural).flat(), ...Object.values(stDeficitIndicatorsNonRural).flat(), ]; let allVars = _.uniqBy(subjectTo.flatMap(st => st.vars), "name"); let binaries = allVars.filter(v => v.type == "binary").map(v => v.name); // allVars.forEach(v => delete v.type); // return { subjectTo, stGlobals, stPmsSlots, stDeficitIndicatorsRural, stDeficitIndicatorsNonRural, stProduction, binaries }; /* Objective */ let stDeficitIndicatorNames = [ ...Object.values(stDeficitIndicatorsRural).flat(), // ...Object.values(stDeficitIndicatorsNonRural).flat() ].map(n => n.name); let stDeficitIndicators = _.uniq(stDeficitIndicatorNames) .map(name => { let { good, slot } = /^has_deficit_(?.*)_(?[\d]+)$/gi.exec(name).groups; return { name, good, slot: parseInt(slot) }; }); return { name: 'LP', objective: { direction: glpk.GLP_MIN, name: "obj", vars: stDeficitIndicators.map(di => ({ name: di.name, coef: 1 + parseFloat((0.1 * di.slot).toFixed(5)) })) }, subjectTo, options: { msglev: glpk.GLP_MSG_ALL, presol: true, tmlim: solverOptions.timeout }, binaries } };52:T553,getTotalProductionCost = { let unitProductionMethods = Object.fromEntries(Object.entries(solutionUnitProduction).map(e => [e[0], e[1].combinedPm])); function getUpstreamGoods(rootGood) { let getInputs = (good) => { let goods = Object.values(unitProductionMethods).filter(pm => pm.outputs.includes(good)).flatMap(pms => pms.inputs); goods = _.uniq(goods); return { follow: _.difference(goods, noFollowGoods), noFollow: _.intersection(goods, noFollowGoods) } }; let starter = fnGetNextLinkedGoods(rootGood); let result = []; let stack = starter.follow; if (noFollowGoods.includes(rootGood)) { stack = stack.concat(starter.noFollow); } else { result = result.concat(starter.noFollow); } while (stack.length) { let good = stack.pop(); let linked = fnGetNextLinkedGoods(good); result.push(good, ...linked.noFollow); result = _.uniq(result); stack = _.uniq([...stack, ...linked.follow]); stack = _.difference(stack, result); // console.log({rootGood, fn: fnGetNextLinkedGoods.name, good, linked, result, stack}); } return result; return getAllLinkedGoods(rootGood, getInputs); } function getTotalProductionCost(output) { return solutionUnitProduction[output].combinedPm } return getTotalProductionCost; }53:Ta55,processedSolutionPmsChains = { if (!solutionPmSelections ) return; let pmses = solutionPmSelections; let ruralPmses = pmses.filter(pms => buildings[pms.building].category == "rural"); let ruralOutputs = ruralPmses.flatMap(pms => pms.outputs).filter(o => !hackGoods.includes(o)); function getSupplyChains(pms, chain) { chain ??= [pms]; // let indent = "".padStart(chain.length * 2); // console.log(indent + "getSupplyChains", pms.building, chain); let isRural = ruralPmses.includes(pms) || chain.some(pms => ruralPmses.includes(pms)); let allOutputs = _.uniq(chain.flatMap(a => a.outputs)); let neededInputs = pms.inputs.filter(i => !hackGoods.includes(i) && !allOutputs.includes(i)); // console.log(indent + 'neededInputs', neededInputs); if (neededInputs.length == 0) return [chain]; let suppliers = pmses.filter(pms => chain.head != pms && !allOutputs.includes(pms)) .filter(pms => pms.outputs.some(i => neededInputs.includes(i))) .filter(pms => !chain.includes(pms)); if (isRural) suppliers = suppliers.filter(s => ruralPmses.includes(s)); if (suppliers.length == 0) return [chain]; // console.log(indent + 'suppliers', suppliers); return suppliers.flatMap(s => getSupplyChains(s, [...chain, s])); } let result = { buildings: {}, pmses: {}, goods: Object.fromEntries(availableGoods.map(g => [g, 0])), goodsFull: Object.fromEntries(availableGoods.map(g => [g, []])) } for (let pms of pmses) { result.buildings[pms.building] ??= 0; let chains = getSupplyChains(pms); let longestChain = Math.max(...chains.map(c => c.length)); result.buildings[pms.building] = Math.max(result.buildings[pms.building] ?? 0, longestChain); result.pmses[pms.id] = Math.max(result.pmses[pms.id] ?? 0, longestChain); // TODO?: maybe find the point at which _most_ has been produced? if (!buildings[pms.building].is_subsistence) { pms.outputs.forEach(o => result.goods[o] = Math.max(result.goods[o] ?? 0, result.pmses[pms.id])); pms.outputs.forEach(o => result.goodsFull[o].push(..._.uniq(chains.map(c => c.length)))); } } result.buildings = Object.fromEntries(_.sortBy(Object.entries(result.buildings), [1, 0])); result.pmses = Object.fromEntries(_.sortBy(Object.entries(result.pmses), [1, 0])); result.goods = Object.fromEntries(_.sortBy(Object.entries(result.goods), [1, 0])); result.goodsFull = Object.fromEntries(_.sortBy(Object.entries(result.goodsFull), 0)); Object.keys(result.goodsFull).forEach(g => result.goodsFull[g] = _.sortBy(_.uniq(result.goodsFull[g]))); return result; }54:Tcce,transformedSolution = { if (!solution || typeof(solution) == "string") return; let status = glpk.statuses[solution.result.status]; let totalBuildings, slackVars, solutionPmses, combinedPm, net, popConsumptionRates, error; let vars = solution?.result?.vars; try { solutionPmses = []; combinedPm = new ProductionMethod(); popConsumptionRates = {}; slackVars = {}; net = {}; for (let [varName, value] of Object.entries(vars).filter(e => e[0] != "slack" && e[0].includes("slack"))) { if (correctPrecision(value) == 0) continue; let sign = varName.includes("|pos|") ? 1 : -1; varName = varName.replace("|pos|slack", "").replace("|neg|slack", ""); slackVars[varName] = correctPrecision(sign * value); } for (let [needId, need] of Object.entries(common.pop_needs)) { let totalNeedSpend = vars[glpkNamer.getName(needId, "spend")]; popConsumptionRates[needId] = {}; for (let goodId of need.entry.map(e => e.goods)) { let needGoodSpend = vars[glpkNamer.getName(needId, goodId, "spend")]; if (!isNaN(needGoodSpend)) { popConsumptionRates[needId][goodId] = correctPrecision(needGoodSpend / totalNeedSpend); } } } for (let [pmsid, count] of Object.entries(vars).filter(v => correctPrecision(v[1]) != 0)) { let pms = availablePmSelections.find(pms => pms.id == pmsid); if (!pms) continue; solutionPmses.push({ count, pms, pmsid }); combinedPm = combinedPm.combine(pms.combinedPm.scale(count)); } totalBuildings = { standard: 0, subsistence: 0 }; let buildingCounts = solutionPmses.map(spms => ({ building: spms.pms.building, count: spms.count })); for (let bc of buildingCounts) { let field = buildings[bc.building].is_subsistence ? "subsistence" : "standard"; totalBuildings[field] += bc.count; } solutionPmses.sort((a,b) => availablePmSelections.indexOf(a) - availablePmSelections.indexOf(b)); combinedPm.id = "solution result"; Object.entries(combinedPm.outputs).forEach(([good, amount]) => { net[good] = (net[good] ?? 0) + amount; }); Object.entries(combinedPm.inputs).forEach(([good, amount]) => { net[good] = (net[good] ?? 0) - amount; }); Object.entries(combinedPm.employment).forEach(([popType, count]) => { if (count == 0) return; let popConsumption = popNeedSpend[popType].scale(count / PopType.workersPerBuyPackage); for (let [good, amount] of Object.entries(popConsumption.getConsumptionVolumes(popConsumptionRates))) { net[good] = (net[good] ?? 0) - amount; } }); if (!solverOptions.intMode) { Object.keys(net).forEach(good => { net[good] = parseFloat(net[good].toFixed(5)); }); } Object.keys(net).forEach(good => { if (net[good] == 0) delete net[good]; }); net = sortObjectByKeys(net); //, k => availableGoods.indexOf(k)); } catch (e) { error = e; console.log('error processing solution', e); } let result = { status, slack: vars?.slack, slackVars, totalBuildings, solutionPmses, combinedPm, popConsumptionRates, net, error }; result = Object.fromEntries(Object.entries(result).filter(r => r[1])); return result; }55:T113f,async function getCostToProduce(targetGoodId) { let problemTarget = {}; problemTarget[targetGoodId] = 1; let targetGoodProducingPmses = availablePmSelections.filter(pms => pms.outputs.includes(targetGoodId)); let otherPmses = _.difference(availablePmSelections, targetGoodProducingPmses); let allocatedPmses = targetGoodProducingPmses.flatMap(pms => splitPmSelection(pms, targetGoodId)); let problemPmses = allocatedPmses.concat(...otherPmses); let problem = getProblem({ problemTarget, availablePmSelections: problemPmses }); let solver = await glpk.getSolver(); let solution = await solver.solve(problem); solver.terminate(); let vars = solution.result.vars; let solutionPmses = []; for (let pms of problemPmses) { let qty = correctPrecision(vars[glpkNamer.getName(pms.id)]); if (qty) solutionPmses.push({ pms, qty }); } let goodsOrders = { total: {} }; for (let goodId of Object.keys(goods)) { let total = correctPrecision(vars[glpkNamer.getName(goodId)]); if (total) goodsOrders.total[goodId] = (goodsOrders.total[goodId] ?? 0) + total; for (let field of ["input", "output", "consumed", "imported"]) { let qty = correctPrecision(vars[glpkNamer.getName(goodId, field)]); if (qty) { goodsOrders[field] ??= {}; goodsOrders[field][goodId] = (goodsOrders[field][goodId] ?? 0) + qty; } } } let pops = {}; let workers = 0; let individuals = 0; for (let popType of Object.keys(popTypes)) { let qty = correctPrecision(vars[glpkNamer.getName(popType)]); if (qty) { pops[popType] = Math.round(qty * PopType.workersPerBuyPackage); workers += qty * PopType.workersPerBuyPackage; individuals += qty * popTypes[popType].individualsPerBuyPackage; } } workers = Math.round(workers); individuals = Math.round(individuals); let popConsumptionRates = getDefaultPopConsumptionRates(); for (let [needId, goods] of Object.entries(popConsumptionRates)) { let needSpend = vars[glpkNamer.getName(needId, "spend")]; for (let goodId of Object.keys(goods)) { let consumptionRate = 0; if (needSpend) { let goodSpend = vars[glpkNamer.getName(needId, goodId, "spend")]; consumptionRate = correctPrecision(goodSpend / needSpend); } popConsumptionRates[needId][goodId] = consumptionRate; } } let finalBalance = goodsOrders.total; // surplusProduction: Whatever we made that we didn't need to let surplusProduction = sumItems(finalBalance, scaleItems(problemTarget, -1)); // goodsRequired: Everything we made or imported to be able to hit the target (output + imported - target - surplus) let goodsRequired = sumItems(goodsOrders.output, goodsOrders.imported ?? {}); goodsRequired = sumItems(goodsRequired, scaleItems(problemTarget, -1)); goodsRequired = sumItems(goodsRequired, scaleItems(surplusProduction, -1)); // goodsRequiredByPops: Everything the pops ate let goodsRequiredByPops = goodsOrders.consumed; // goodsRequiredToProduce: goodsRequired - goodsRequiredByPops let goodsRequiredToProduce = sumItems(goodsRequired, scaleItems(goodsRequiredByPops, -1)); // overhead: hackGoods let overhead = _.pickBy(goodsRequired, (v,k) => hackGoods.includes(k)); delete overhead.trade_routes; // package it up let quantities = { goodsRequired, goodsRequiredByPops, goodsRequiredToProduce, surplusProduction, overhead }; let costs = {}; // delete zero-quantity goods, if any, and calculate costs for (let [field, obj] of Object.entries(quantities)) { let keysToDelete = Object.keys(obj).filter(g => !obj[g]); if (field != "surplusProduction" && field != "overhead") keysToDelete = keysToDelete.concat(hackGoods); keysToDelete.forEach(g => delete obj[g]); sortObjectByKeys(obj, g => Object.keys(goods).indexOf(g)); let subCosts = Object.entries(obj) .filter(e => !hackGoods.includes(e[0])) .map(e => correctPrecision(e[1] * goods[e[0]].cost)); costs[field] = _.sum(subCosts); } quantities.overhead = overhead; return { goal: problemTarget, buildingsRequired: correctPrecision(vars["buildings"]), finalBalance, quantities, costs, population: { individuals, workers, popsEmployed: pops, }, solutionPmses, popConsumptionRates, problem, solution: solution, } }56:T527,_problemTarget = { let popGoods; { let needGoods = { hackNeeds: Object.keys(popTypeConsumption.peasants.hackNeeds) }; for (let consumption of Object.values(popTypeConsumption)) { for (let needId of consumption.needIds) { needGoods[needId] ??= Object.keys(consumption[needId].goods); } } popGoods = _.uniq(Object.values(needGoods).flat()); } let categoryAmounts = { // category: [ always, terminal, terminalOfCurrentEra ], hack: [0, 0, 0], industrial: [0, 0, 25], luxury: [0, 2, 2], military: [50, 50, 50], staple: [0, 0, 0] } let allInputs = _.uniq(availablePmSelections.flatMap(pms => pms.inputs)); let allOutputs = _.uniq(availablePmSelections.flatMap(pms => pms.outputs)); let terminalOutputs = _.difference(allOutputs, allInputs); let candidateGoods = producableGoods.filter(g => !(hackGoods.concat(popGoods).includes(g))); let targets = {}; for (let goodId of candidateGoods) { let good = goods[goodId]; let caIndex = 0; if (terminalOutputs.includes(goodId)) { caIndex = 1; if (good.era == selectedEra && selectedEra != maxEra) caIndex = 2; } let minToProduce = categoryAmounts[good.category][caIndex]; if (minToProduce > 0) targets[goodId] = minToProduce; } return targets; }57:T473,// TODO: bring goodsAvailability in here, then deprecate it goodsMeta = { let outputGoods = availablePmSelections.flatMap(pms => pms.outputs); let inputGoods = availablePmSelections.flatMap(pms => pms.inputs); let consumedGoods = _.uniq(Object.values(popTypeConsumption) .flatMap(p => p.needIds.map(n => p[n])) .flatMap(n => Object.keys(n.goods))); let hackConsumed = [], hackOutputs = []; for (let hackNeed of Object.values(popTypeConsumption).map(p => p.hackNeeds)) { for (let [goodId, amount] of Object.entries(hackNeed)) { if (amount > 0) hackConsumed.push(goodId); if (amount < 0) hackOutputs.push(goodId); } } outputGoods = _.uniq(outputGoods.concat(hackOutputs)); inputGoods = _.uniq(inputGoods); consumedGoods = _.uniq(consumedGoods.concat(hackConsumed)); let goodsMeta = {} for (let goodId of Object.keys(goods)) { if (goodsAvailability[goodId] != "can_produce") continue; goodsMeta[goodId] = { isOutput: outputGoods.includes(goodId), isInput: inputGoods.includes(goodId), isConsumed: consumedGoods.includes(goodId), } } return goodsMeta }58:T1367,supplyChainStats = { let solver = await glpk.getSolver(); let stats = new Map(); for (let goodId of availableGoods.filter(g => g != "tax_capacity")) { let target = {}; target[goodId] = 100; let problemSubjectTo = getProblemSubjectTo(target, ["tax_capacity"]); let problem = { name: 'LP', objective: { direction: glpk.GLP_MIN, name: "obj", vars: [ { name: "buildings", coef: 1 }, { name: "slack", coef: 1e-3 }, { name: "goodsSurplusValue", coef: 1e-6 }, { name: "popConsumptionImbalance", coef: 1e-6 } ] }, subjectTo: problemSubjectTo.subjectToArray, bounds: problemSubjectTo.bounds, options: { mipgap: 0, msglev: glpk.GLP_MSG_ERR, presol: true } } let solution = await solver.solve(problem); let vars = solution.result.vars; let popConsumptionRates = {}; for (let [needId, need] of Object.entries(common.pop_needs)) { let totalNeedSpend = vars[glpkNamer.getName(needId, "spend")]; popConsumptionRates[needId] = {}; for (let goodId of need.entry.map(e => e.goods)) { let needGoodSpend = vars[glpkNamer.getName(needId, goodId, "spend")]; popConsumptionRates[needId][goodId] = correctPrecision(needGoodSpend / totalNeedSpend); } } return "Fudge. You gotta do the single-output allocation in the solver. :-("; let allPms = []; let combinedPm = new ProductionMethod(); let directCombinedPm = new ProductionMethod(); let bonusCombinedPm = new ProductionMethod(); let indirectCombinedPm = new ProductionMethod(); for (let [pmsId, count] of Object.entries(vars).filter(v => correctPrecision(v[1]) != 0)) { let pms = availablePmSelections.find(pms => pms.id == pmsId); if (!pms) continue; let pm = pms.combinedPm.scale(count); allPms.push(pm); combinedPm = combinedPm.combine(pm); if (!pms.outputs.includes(goodId)) { indirectCombinedPm = indirectCombinedPm.combine(pm); } else { //let totalOutputVolume = pms.combinedPm.outputs[goodId]; let allocatedPmses = allocatePmSelection(pms); let directPm = allocatedPmses.find(pms => pms.output == goodId).combinedPm; directCombinedPm = directCombinedPm.combine(directPm.scale(count)); let bonusPms = allocatedPmses.filter(pms => pms.output != goodId).map(pms => pms.combinedPm); for (let bonusPm of bonusPms) { bonusCombinedPm = bonusCombinedPm.combine(bonusPm.scale(count)); } } } let output100 = combinedPm.outputs[goodId] / 100; if (correctPrecision(output100) != 1) { combinedPm = combinedPm.scale(output100); bonusCombinedPm = bonusCombinedPm.scale(output100); directCombinedPm = directCombinedPm.scale(output100); indirectCombinedPm = indirectCombinedPm.scale(output100); } directCombinedPm.id = `${goodId}-producing buildings: ${directCombinedPm.id}`; indirectCombinedPm.id = "upstream buildings"; let totalPopConsumption = {}; Object.entries(combinedPm.employment).forEach(([popType, count]) => { if (count == 0) return; let popConsumption = popTypeConsumption[popType].scale(count / PopConsumption.defaultSize); for (let [good, amount] of Object.entries(popConsumption.getConsumptionVolumes(popConsumptionRates))) { totalPopConsumption[good] = (totalPopConsumption[good] ?? 0) + amount; } }); let result = { inputs: {}, employment: {}, breakdown: {} } for (let pm of allPms) { for (let [goodId, amount] of Object.entries(pm.inputs)) { result.inputs[goodId] = (result.inputs[goodId] ?? 0) + amount; } for (let [popType, count] of Object.entries(pm.employment)) { result.employment[popType] = (result.employment[goodId] ?? 0) + count; } } return { result, combinedPm, bonusCombinedPm, directCombinedPm, indirectCombinedPm, totalPopConsumption } /* Object.entries(combinedPm.employment).forEach(([popType, count]) => { if (count == 0) return; let popConsumption = popTypeConsumption[popType].scale(count / PopConsumption.defaultSize); for (let [good, amount] of Object.entries(popConsumption.getConsumptionVolumes(popConsumptionRates))) { net[good] = (net[good] ?? 0) - amount; } }); pms.combinedPm.forSingleOutput(output); let parsed = { netOutput: {}, netInput: {}, goods: {} }; for (let goodId of Object.keys(availableGoods)) { let good = { } } glpkNamer.getName electricity: 0 electricity|output: 11.955820492848558 electricity|input: 11.955820492848556 electricity|consumed: 0 stats.set(pmsId, solution.result.vars); yield stats; //stats.set(pmsId, problemSubjectTo); */ } // yield stats; };59:T490,stats = { let pmSelections = availablePmSelections .filter(pms => !buildings[pms.building]?.is_subsistence) .filter(pms => _.difference(pms.outputs, hackGoods).length); let lookup = new Map(); for (let pms of availablePmSelections) { let stats = {}; lookup.set(pms, stats); let pm = pms.combinedPm; let popConsumption = {}; Object.entries(pm.employment).forEach(([popType, count]) => { if (count == 0) return; popConsumption[popType] = popTypeConsumption[popType].scale(count / PopConsumption.defaultSize); }); stats.popsEmployed = _.sum(Object.values(pm.employment)) / PopConsumption.defaultSize; stats.outputQty = _.sum(Object.values(pm.outputs)); stats.inputQty = _.sum(Object.values(pm.inputs)); if (pms.outputs.every(g => hackGoods.includes(g))) continue; stats.popsEmployedSpend = _.sum(Object.values(popConsumption).map(pc => pc.totalSpend)); stats.outputValue = _.sum(Object.entries(pm.outputs).map(e => e[1] * (goods[e[0]]?.cost ?? 0))); stats.inputValue = _.sum(Object.entries(pm.inputs).map(e => e[1] * (goods[e[0]]?.cost ?? 0))); } return lookup; }5a:T30f5,getProblemSubjectTo = { let defaultParams = { problemTarget, importableGoods, availablePmSelections, popNeedSpend, popConsumptionRanges }; function getProblemSubjectTo(params) { params = Object.assign({}, defaultParams, params); let { problemTarget, importableGoods, availablePmSelections, popNeedSpend, popConsumptionRanges } = params; // let target ??= problemTarget; let urbanizationPerBuilding = common.defines.NEconomy.URBANIZATION_PER_BUILDING; urbanizationPerBuilding *= (1 + effectiveModifierValues.special.state_urbanization_mult); urbanizationPerBuilding = correctPrecision(urbanizationPerBuilding); let mustImportGoods = _.intersection(importableGoods, consumedGoods.concat(Object.keys(problemTarget))); let availableGoods = producableGoods.concat(mustImportGoods); let buildingPmSelections = availablePmSelections.filter(pms => !pms.isTrade); let tradePmSelections = availablePmSelections.filter(pms => pms.isTrade) .filter(pms => mustImportGoods.includes(pms.outputs[0])); if (mustImportGoods.length == 0) { buildingPmSelections = buildingPmSelections.filter(pms => !pms.inputs.concat(pms.outputs).includes("trade_routes")); } availablePmSelections = buildingPmSelections.concat(tradePmSelections); let binaries = []; let generals = []; let bounds = [ // Define "constant", a fake variable hard-coded to 1 { name: "constant", type: glpk.GLP_FX, lb: 1 }, // Indicate that infrastructure consumption is negative { name: glpkNamer.getName("infrastructure", "consumed"), type: glpk.GLP_UP, ub: 0 }, // Pin trade_routes to 0 to enforce trade center balance { name: "trade_routes", type: glpk.GLP_FX, lb: 0 }, ]; if (solverOptions.intMode) { // Pin urbanization between 0 and -99 to enforce urban center balance bounds.push({ name: "urbanization", type: glpk.GLP_DB, ub: 0, lb: 1 - urbanizationPerBuilding }); } else { // Pin urbanization to 0 to enforce urban center balance bounds.push({ name: "urbanization", type: glpk.GLP_FX, lb: 0 }); } for (let [objId, targetQty] of Object.entries(problemTarget)) { bounds.push({ name: glpkNamer.getName(objId), type: glpk.GLP_FX, lb: targetQty }); } // Additional bounds created later for imported goods present in problemTarget let subjectTo = { goods: {}, goodsOutput: {}, goodsInput: {}, goodsImported: {}, goodsConsumed: {}, tradeRouteBalance: {}, popTypes: {}, needSpend: {}, needGoodsSpend: {}, needGoodsSpendPct: {}, needGoodsSpendDev: {}, objectives: {}, }; // subjectTo.goods: Sum of PMS input/output and pop consumption/output per good for (let goodId of availableGoods) { let constraint = subjectTo.goods[goodId] ??= getOrCreateBalancingConstraintNamed(goodId); setConstraintVar(constraint, [goodId, "output"], 1); setConstraintVar(constraint, [goodId, "imported"], 1); setConstraintVar(constraint, [goodId, "input"], -1); setConstraintVar(constraint, [goodId, "consumed"], -1); } // subjectTo.goodsInput: Input volumes per pms for (let pms of availablePmSelections) { for (let goodId of pms.inputs) { let constraint = subjectTo.goodsInput[goodId] ??= getOrCreateBalancingConstraint(goodId, "input"); addConstraintVar(constraint, pms.id, pms.combinedPm.inputs[goodId]); } } // subjectTo.goodsInput: Fixed value for number of trade_routes subjectTo.goodsInput["trade_routes"] = { name: glpkNamer.getName("trade_routes", "input", "def"), vars: [ { name: glpkNamer.getName("trade_routes", "input"), coef: 1 }], bnds: { type: glpk.GLP_FX, lb: mustImportGoods.length } }; // subjectTo.goodsOutput: Output volumes per building pms for (let pms of buildingPmSelections) { for (let goodId of pms.outputs) { let constraint = subjectTo.goodsOutput[goodId] ??= getOrCreateBalancingConstraint(goodId, "output"); addConstraintVar(constraint, pms.id, pms.combinedPm.outputs[goodId]); } } // subjectTo.goodsImported: Output volumes per trade pms (i.e. quantity of goods imported) for (let pms of tradePmSelections) { for (let goodId of pms.outputs.filter(o => mustImportGoods.includes(o))) { let importVarName = glpkNamer.getName(goodId, "imported"); let constraint = subjectTo.goodsImported[goodId] ??= getOrCreateBalancingConstraint(importVarName); addConstraintVar(constraint, pms.id, pms.combinedPm.outputs[goodId]); bounds.push({ name: importVarName, type: glpk.GLP_FX, lb: problemTarget[goodId] }); } } // subjectTo.objectives: Total number of buildings subjectTo.objectives["buildings"] = getOrCreateBalancingConstraint("buildings"); for (let pms of availablePmSelections) { let coef = 1; if (buildings[pms.building].is_subsistence) coef = solverOptions.subsistenceBuildingWeight; if (pms.building == "building_urban_center") coef = 0; if (pms.building == "_trade_route") coef = 0; addConstraintVar(subjectTo.objectives["buildings"], pms.id, coef); } // subjectTo.objectives: Total quantity and total value of non-required goods produced for (let [goodId, value] of Object.entries(goods).filter(e => !hackGoods.includes(e[0])).map(e => [e[0], e[1].cost])) { let goodTarget = problemTarget[goodId] ?? 0; let qtyConstraint = subjectTo.objectives["qty"] ??= getOrCreateBalancingConstraint("goodsSurplusQty"); setConstraintVar(qtyConstraint, goodId, 1); addConstraintVar(qtyConstraint, "constant", -goodTarget); if (!value) continue; let valueConstraint = subjectTo.objectives["value"] ??= getOrCreateBalancingConstraint("goodsSurplusValue"); setConstraintVar(valueConstraint, goodId, value); addConstraintVar(valueConstraint, "constant", -goodTarget * value); } // subjectTo.popTypes: Pop employment per pms for (let pms of availablePmSelections) { let combinedPm = pms.combinedPm; for (let [popType, count] of Object.entries(pms.combinedPm.employment)) { let constraint = subjectTo.popTypes[popType] ??= getOrCreateBalancingConstraint(popType); let numPops = count / PopType.workersPerBuyPackage; addConstraintVar(constraint, pms.id, numPops); } } // subjectTo.needSpend: Pop spend per need for (let [popType, needSpend] of Object.entries(popNeedSpend)) { for (let needId of needSpend.needIds) { let constraint = subjectTo.needSpend[needId] ??= getOrCreateBalancingConstraint(needId, "spend"); addConstraintVar(constraint, popType, needSpend[needId]); } } // subjectTo.needGoodsSpend: Goods spend per need // subjectTo.needGoodsSpendPct: min and max goods spend per need, sum of total good spend per need // subjectTo.needGoodsSpendDev: deviation in goods spend from target values let totalSpendDeviationName = glpkNamer.getName("total", "spend"); let totalDeviationConstraint = subjectTo.needGoodsSpendDev["total"] = getOrCreateBalancingConstraint("popConsumptionImbalance"); for (let [needId, needSpend] of Object.entries(popConsumptionRanges)) { let totalSpendName = glpkNamer.getName(needId, "spend"); let totalSpendConstraint = subjectTo.needGoodsSpend[needId] ??= getOrCreateBalancingConstraintNamed(totalSpendName, [totalSpendName, "goods", "def"]); for (let goodId of Object.keys(needSpend)) { let { weight, spendPctRange } = needSpend[goodId]; let goodSpendName = glpkNamer.getName(needId, goodId, "spend"); setConstraintVar(totalSpendConstraint, goodSpendName, 1); // minimum spend constraint: need|good|spend >= min * need|spend let minSpendConstraint = subjectTo.needGoodsSpendPct[goodSpendName + "_min"] = { name: glpkNamer.getName(goodSpendName, "min", "def"), vars: [ { name: totalSpendName, coef: -spendPctRange[0] }, { name: goodSpendName, coef: 1 } ], bnds: { type: glpk.GLP_LO, lb: 0 } }; if (spendPctRange[0] == spendPctRange[1]) { minSpendConstraint.bnds = { type: glpk.GLP_FX, lb: 0 } } else { // maximum spend constraint: need|good|spend <= max * need|spend subjectTo.needGoodsSpendPct[goodSpendName + "_max"] = { name: glpkNamer.getName(goodSpendName, "max", "def"), vars: [ { name: totalSpendName, coef: -spendPctRange[1] }, { name: goodSpendName, coef: 1 } ], bnds: { type: glpk.GLP_UP, ub: 0 } }; }; // deviation from needs' default weights let devVarName = glpkNamer.getName(goodSpendName, "deviation"); subjectTo.needGoodsSpendDev[devVarName + "_1"] = { name: glpkNamer.getName(devVarName, "def") + 1, vars: [ {name: goodSpendName, coef: 1}, {name: totalSpendName, coef: -weight}, {name: devVarName, coef: 1} ] }; subjectTo.needGoodsSpendDev[devVarName + "_2"] = { name: glpkNamer.getName(devVarName, "def") + 2, vars: [ {name: goodSpendName, coef: -1}, {name: totalSpendName, coef: weight}, {name: devVarName, coef: 1} ] }; addConstraintVar(totalDeviationConstraint, devVarName, 1); } } // subjectTo.goodsConsumed: Total standard goods purchased given spend for (let [needId, needSpend] of Object.entries(popConsumptionRanges)) { for (let goodId of Object.keys(needSpend)) { let goodConsumedName = glpkNamer.getName(goodId, "consumed"); let constraint = subjectTo.goodsConsumed[goodId]; if (!constraint) { constraint = subjectTo.goodsConsumed[goodId] = getOrCreateBalancingConstraint(goodConsumedName); constraint.vars[0].coef = -goods[goodId].cost; } setConstraintVar(constraint, [needId, goodId, "spend"], 1); } } // subjectTo.goodsConsumed: Total hackGoods produced or consumed given pop type for (let [popType, needSpend] of Object.entries(popNeedSpend)) { for (let [goodId, qty] of Object.entries(needSpend.hackGoodConsumption ?? {})) { let constraint = subjectTo.goodsConsumed[goodId] ??= getOrCreateBalancingConstraint(goodId, "consumed"); addConstraintVar(constraint, popType, qty); } } // bounds: Removed unused goods values so the model can't just invent a number it likes to fake balance things for (let group of ["output", "input", "imported", "consumed"]) { for (let goodId of Object.keys(subjectTo.goods)) { let obj = subjectTo[_.camelCase(`goods ${group}`)]; if (!obj[goodId]) { let constraint = subjectTo.goods[goodId]; constraint.vars = constraint.vars.filter(v => v.name != glpkNamer.getName(goodId, group)); } } } // subjectTo.goods: Remove totally unused goods subjectTo.goods = Object.fromEntries(Object.entries(subjectTo.goods).filter(e => e[1].vars.length > 1)); /* // Add slack variables for debugging purposes let totalSlackConstraint = subjectTo.objectives["slack"] ??= getOrCreateBalancingConstraint("slack"); for (let [goodId, constraint] of Object.entries(subjectTo.goods)) { let slackVar1 = glpkNamer.getName(goodId, "slack", "pos"); let slackVar2 = glpkNamer.getName(goodId, "slack", "neg"); constraint.vars.push({ name: slackVar1, coef: 1 }); constraint.vars.push({ name: slackVar2, coef: -1 }); totalSlackConstraint.vars.push({ name: slackVar1, coef: 1 }); totalSlackConstraint.vars.push({ name: slackVar2, coef: 1 }); } */ // Add bounds to all unbounded variables let subjectToArray = []; for (let group of Object.values(subjectTo)) { subjectToArray.push(...Object.values(group)); } subjectToArray.forEach(c => c.bnds ??= { type: glpk.GLP_LO, lb: 0 }); subjectToArray.sort((a,b) => glpkNamer.compareNames(a.name, b.name)); return { subjectTo, subjectToArray, bounds, binaries, generals }; // return subjectTo; return _.sortBy(subjectTo, "name"); } return getProblemSubjectTo; }5b:T1009,glpkNamer = { const tokenOrder = ["pmsId", "popType", "needId", "goodId", "goodFlag", "needFlag"]; const suffixOrder = ["min", "max", "target", "pos", "neg", "deviation", "*", "def"]; let suffixComparator; { let starIndex = suffixOrder.indexOf("*"); function getIndex(a) { let index = suffixOrder.indexOf(a); return (index < 0) ? starIndex : index; } suffixComparator = (a,b) => (getIndex(a) - getIndex(b)) || a.localeCompare(b); } let typeMap = new Map(); productionMethodSelections.map(pms => pms.id).forEach(p => typeMap.set(p, "pmsId")); Object.keys(goods).map(g => `trading_${g}`).forEach(g => typeMap.set(g, "pmsId")); Object.keys(common.pop_types).forEach(p => typeMap.set(p, "popType")); Object.keys(common.pop_needs).forEach(n => typeMap.set(n, "needId")); Object.keys(goods).forEach(g => typeMap.set(g, "goodId")); ["spend", "weight"].forEach(f => typeMap.set(f, "needFlag")); ["produced", "consumed", "imported"].forEach(f => typeMap.set(f, "goodFlag")); suffixOrder.forEach(s => { if (s != "*") typeMap.set(s, "suffixes") }); function stringOrId(objOrString) { if (typeof(objOrString) != "object") return objOrString; return objOrString.id ?? objOrString._id ?? objOrString; } function buildParams(array, params) { array ??= []; params = Object.assign({ suffixes: [] }, params); array = array.flatMap(e => { if (typeof(e) != "string") return stringOrId(e); if (typeMap.has(e)) return e; let split = e.split("|"); if (split.every(se => typeMap.has(se))) return split; return e; }); // Initialize params based on array for (let entry of array.map(e => stringOrId(e))) { let fieldName = typeMap.get(entry); if (!fieldName || fieldName == "suffixes") { params.suffixes.push(entry); } else { if (params[fieldName] && params[fieldName] != entry) throw `glpkNamer: provided multiple values for ${fieldName}`; params[fieldName] = entry; } } // params cleanup params.suffixes = _.uniq(params.suffixes); params.suffixes.sort(suffixComparator); delete params.flags; return params; } function readName(name) { return buildParams(name.split("|")); } function getName(...paramsOrArray) { let array = []; let params = { suffixes: [] } // Initialize array and params based on value of paramsOrArray if (paramsOrArray === undefined || paramsOrArray.length === 0) throw "getName: called without parameter"; if (paramsOrArray.length == 1) { let singleton = paramsOrArray[0]; if (typeof(singleton) == "string") { array = singleton.split("|"); } else if (Array.isArray(singleton)) { array = singleton; } else if (typeof(singleton) == "object" && typeof(stringOrId(singleton)) == "string") { console.log('singleton'); array = [singleton]; } else { params = Object.assign(params, _.cloneDeep(singleton)); if (params.flags) array = params.flags; } } else { array = paramsOrArray; } params = buildParams(array, params); let tokens = tokenOrder .map(t => params[t]) .concat(params.suffixes) .filter(t => t); if (tokens.length == 0) { throw ({paramsOrArray, params, array}); } return tokens.join("|"); } function compareNames(a, b) { if (!a) return -1; if (!b) return 1; let parsedA = readName(a); let parsedB = readName(b); let firstMismatch = tokenOrder.find(t => parsedA[t] != parsedB[t]); if (firstMismatch == "goodId") { return Object.keys(goods).indexOf(parsedA.goodId) - Object.keys(goods).indexOf(parsedB.goodId); } if (firstMismatch) { if (!parsedA[firstMismatch]) return -1; if (!parsedB[firstMismatch]) return 1; return (parsedA[firstMismatch] || "").localeCompare(parsedB[firstMismatch] || ""); } return (a || "").localeCompare(b || ""); } return { readName, getName, compareNames }; }5c:T5dd,effectiveModifierValues = { let buildings = Object.fromEntries(buildingModifierIds.map(m => [m, 0])); let special = Object.fromEntries(specialModifierIds.map(m => [m, 0])); special.market_disallow_trade_routes = false; for (let [m, value] of Object.entries(_.pick(common.modifiers.base_values, knownModifierIds))) { if (buildings[m] !== undefined) buildings[m] = value; if (special[m] !== undefined) special[m] = value; } function addValue(obj, key, value) { if (typeof(value) == "boolean") { obj[key] = obj[key] || value; return; } obj[key] += value; } for (let law of selectedLaws.map(id => laws[id])) { for (let [m, value] of Object.entries(_.pick(law.modifier ?? {}, knownModifierIds))) { if (buildings[m] !== undefined) addValue(buildings, m, value); if (special[m] !== undefined) addValue(special, m, value); } } for (let tech of availableTechnology.map(id => common.technologies[id])) { for (let [m, value] of Object.entries(_.pick(tech.modifier ?? {}, knownModifierIds))) { if (buildings[m] !== undefined) addValue(buildings, m, value); if (special[m] !== undefined) addValue(special, m, value); } } for (let m of buildingModifierIds) { if (buildings[m] == 0) delete buildings[m]; } Object.keys(buildings).forEach(m => buildings[m] = correctPrecision(buildings[m])); Object.keys(special).forEach(m => special[m] = correctPrecision(special[m])); return { buildings, special }; }5d:Tc34,availablePmSelections = { // Get the eligible productionMethodSelections let availablePmses = productionMethodSelections .filter(pms => availableInEra(pms, selectedEra)) .filter(pms => !pms.outputs.includes("gold")) .filter(pms => !buildings[pms.building].is_subsistence) .filter(pms => pms.unlockingLaws.every(l => selectedLaws.includes(l))) .filter(pms => pms.disallowingLaws.every(l => !selectedLaws.includes(l))) .map(pms => ({...pms})); // Split into two groups let normalPmses = availablePmses.filter(pms => !pms.isTrade) let tradePmses = availablePmses.filter(pms => pms.isTrade && importableGoods.includes(pms.outputs[0])); // Apply any active modifiers to the normalPmses let activeBuildingModifiers = Object.keys(effectiveModifierValues.buildings).map(id => buildingModifiers[id]); for (let i = 0; i < normalPmses.length; i++) { let pms = normalPmses[i]; let modifiersToApply = activeBuildingModifiers .filter(m => !m.buildings || m.buildings.includes(pms.building)) .filter(m => !m.good || pms.inputs.includes(m.good) || pms.outputs.includes(m.good)); if (modifiersToApply.length == 0) continue; let newPms = _.cloneDeep(pms); newPms.modified = true; newPms.selectedPms = pms.selectedPms.map(pm => pm.copy()); newPms.combinedPm = pms.combinedPm.copy(); for (let pm of [newPms.combinedPm, ...newPms.selectedPms]) { modifiersToApply.forEach(m => m.apply(pm, effectiveModifierValues.buildings[m.id])); } normalPmses[i] = newPms; } // Apply any active modifiers to the tradePmses if (effectiveModifierValues.special.market_disallow_trade_routes) tradePmses = []; let routeLengthConvoyPenalty = Math.pow(1 + common.defines.NEconomy.SHIPPING_LANE_CONVOY_COST_SCALING, solverOptions.nodesPerTradeRoute); let tradedQuantityModifier = 1 + effectiveModifierValues.special.country_trade_route_quantity_mult; let bureaucracyCost = common.defines.NEconomy.TRADE_ROUTE_BUREAUCRACY_COST; bureaucracyCost *= (1 + effectiveModifierValues.special.country_trade_route_cost_mult); for (let i = 0; i < tradePmses.length; i++) { let pms = tradePmses[i]; let newPms = _.cloneDeep(pms); newPms.modified = true; newPms.selectedPms = pms.selectedPms.map(pm => pm.copy()); let newPm = pms.selectedPms[0].copy(); if (newPm.id == "trade_route_bureaucracy_cost") { newPm.inputs.bureaucracy = correctPrecision(bureaucracyCost); } else { let goodId = pms.outputs[0]; let good = goods[goodId]; newPm.inputs.convoys_capacity = correctPrecision(good.traded_quantity * good.convoy_cost_multiplier * routeLengthConvoyPenalty); newPm.outputs[goodId] = correctPrecision(good.traded_quantity * tradedQuantityModifier); } newPms.combinedPm = newPm; newPms.combinedPm.id = pms.id; tradePmses[i] = newPms; } let productionMethods = {}; // Sort nicely normalPmses = _.sortBy(normalPmses, pms => pms.combinedPm.id); tradePmses = _.sortBy(tradePmses, pms => pms.combinedPm.id); return tradePmses.concat(normalPmses); }5e:Tc2b,popNeedSpend = { let mods = effectiveModifierValues.special; // get modified values for calculating hackGoodConsumption let workersPerBureaucracy = common.defines.NPolitics.STATE_BUREAUCRACY_POP_MULTIPLE / common.defines.NPolitics.STATE_BUREAUCRACY_POP_BASE_COST; workersPerBureaucracy *= (1 + mods.state_bureaucracy_population_base_cost_factor_mult); workersPerBureaucracy = correctPrecision(workersPerBureaucracy) let individualsPerInfrastructure = common.defines.NPops.INDIVIDUALS_PER_POP_INFRASTRUCTURE; let individualsPerInfrastructureFactor = 1 + mods.state_infrastructure_from_population_add; let individualsPerTaxCapacity = common.defines.NPops.INDIVIDUALS_TAXED_PER_TAX_CAPACITY; // get absolute hackGoodConsumption let hackGoodConsumption = {}; for (let [popTypeId, popType] of Object.entries(popTypes)) { hackGoodConsumption[popTypeId] = { bureaucracy: correctPrecision(PopType.workersPerBuyPackage / workersPerBureaucracy), infrastructure: -correctPrecision(popType.individualsPerBuyPackage * individualsPerInfrastructureFactor / individualsPerInfrastructure), tax_capacity: correctPrecision(popType.individualsPerBuyPackage / individualsPerTaxCapacity) }; } // make hackGoodConsumption relative to peasants let peasantConsumption = _.clone(hackGoodConsumption.peasants); let goodIds = Object.keys(peasantConsumption); for (let [popTypeId, consumption] of Object.entries(hackGoodConsumption)) { goodIds.forEach(g => consumption[g] = correctPrecision(consumption[g] - peasantConsumption[g])); } // build and return needSpend let popNeedSpend = {}; for (let [popTypeId, popType] of Object.entries(popTypes)) { let ns = new NeedSpend(); Object.assign(ns, common.buy_packages[`wealth_${popType.wealthLevel}`].goods); ns = ns.scale(popType.consumptionRate); popNeedSpend[popTypeId] = ns; if (_.sum(Object.values(hackGoodConsumption[popTypeId]).map(v => Math.abs(v)))) { Object.assign(ns.hackGoodConsumption, hackGoodConsumption[popTypeId]); } } return popNeedSpend; //popTypes.academics.getNeedSpend() /* // generate absolute hackGoodConsumption for (let popType of Object.values(popTypes)) { popType.hackGoodConsumption = { infrastructure: -correctPrecision(popType.individualsPerBuyPackage * (1 + mods.state_infrastructure_from_population_add) / individualsPerInfrastructure), tax_capacity: correctPrecision(popType.individualsPerBuyPackage / individualsPerTaxCapacity), bureaucracy: correctPrecision(PopType.workersPerBuyPackage / workersPerBureaucracy) }; } // write down hackGoodConsumption values for peasants let peasantHackNeeds = _.clone(popTypes.peasants.hackGoodConsumption); // convert each popType's hackGoodConsumption to a relative value based on peasants let hackGoods = Object.keys(peasantHackNeeds); for (let hackGoodConsumption of Object.values(popTypes).map(p => p.hackGoodConsumption)) { hackGoods.forEach(g => hackGoodConsumption[g] = correctPrecision(hackGoodConsumption[g] - peasantHackNeeds[g])); } */ }5f:T610,tradeRoutePms = { if (effectiveModifierValues.special.market_disallow_trade_routes) return []; let routeLengthConvoyPenalty = Math.pow(1 + common.defines.NEconomy.SHIPPING_LANE_CONVOY_COST_SCALING, solverOptions.nodesPerTradeRoute); let tradedQuantityModifier = 1 + effectiveModifierValues.special.country_trade_route_quantity_mult; let bureaucracyCost = common.defines.NEconomy.TRADE_ROUTE_BUREAUCRACY_COST; bureaucracyCost *= (1 + effectiveModifierValues.special.country_trade_route_cost_mult); let productionMethods = {}; // because it doesn't scale by trade route level, the trade_routes good is created by the model itself, lol let bcPm = new ProductionMethod(); bcPm.id = "trade_route_bureaucracy_cost"; bcPm.inputs.bureaucracy = correctPrecision(bureaucracyCost); bcPm.outputs.trade_routes = 1; bcPm.unlockingLaws.push("international_trade"); bcPm.disallowingLaws.push("law_isolationism"); productionMethods[bcPm.id] = bcPm; for (let [goodId, good] of importableGoods) { let pm = new ProductionMethod(); pm.id = `trade_route_${goodId}`; pm.inputs.convoys_capacity = correctPrecision(good.traded_quantity * good.convoy_cost_multiplier * routeLengthConvoyPenalty); pm.inputs.trade_route_levels = 1; pm.inputs.urbanization = 0; pm.outputs[goodId] = correctPrecision(good.traded_quantity * tradedQuantityModifier); pm.unlockingLaws.push("international_trade"); pm.disallowingLaws.push("law_isolationism"); productionMethods[pm.id] = pm; } return productionMethods; }60:T195d,ProductionMethod = { function findGoodId(modifierName) { let goodId = modifierName.split("_").slice(2, -1).join("_"); // strips building_input from the beginning and _add from the end let good = common.goods[goodId]; if (!good && !hackGoods.includes(goodId)) return; if (!modifierName.endsWith("add")) throw `Found unexpected modifier ${modifierName}`; return goodId; } function findPopType(modifierName) { let popTypeId = modifierName.split("_").slice(2, -1).join("_"); // strips building_employment from the beginning and _add from the end let popType = common.pop_types[popTypeId]; if (!popType) return; if (!modifierName.endsWith("add")) throw `Found unexpected modifier ${modifierName}`; return popType; } function getUnlockingPms(pm) { let unlockingPms = common.production_methods[pm]?.unlocking_production_methods ?? []; if (unlockingPms.length == 0) return []; return [...unlockingPms, ...unlockingPms.flatMap(pm => getUnlockingPms(pm))]; } class ProductionMethod { constructor(pmOrString) { this.inputs = {}; this.outputs = {}; this.employment = {}; this.unlockingPms = []; this.unlockingLaws = []; this.disallowingLaws = []; if (!pmOrString) return; let pm = (typeof(pmOrString) == "string") ? common.production_methods[pmOrString] : pmOrString; this.id = pm._id; this.era = getEraOf(pm); this.unlockingPms = getUnlockingPms(this.id); this.unlockingLaws = pm.unlocking_laws || []; this.disallowingLaws = pm.disallowing_laws || []; let allModifiers = []; for (let modifierGroup of Object.keys(pm).filter(k => k.endsWith("_modifiers"))) { for (let modifierType of Object.values(pm[modifierGroup])) { allModifiers.push(...Object.entries(modifierType).filter(e => e[0].endsWith("_add"))); } } let getModifiers = (str) => allModifiers.filter(e => e[0].startsWith(str)); let getModifiersAsIO = (modifierString, goodId) => { for (let [key, amount] of getModifiers(modifierString)) { if (amount > 0) this.outputs[goodId] = (this.outputs[goodId] ?? 0) + amount; if (amount < 0) this.inputs[goodId] = (this.inputs[goodId] ?? 0) - amount; } }; // Inputs for (let [key, amount] of getModifiers("building_input_")) { let goodId = findGoodId(key); if (!goodId) continue; this.inputs[goodId] = (this.inputs[goodId] ?? 0) + amount; } // Outputs for (let [key, amount] of getModifiers("building_output_")) { let goodId = findGoodId(key); if (!goodId) continue; this.outputs[goodId] = (this.outputs[goodId] ?? 0) + amount; } // Employment for (let [key, amount] of getModifiers("building_employment_")) { let popType = findPopType(key); if (!popType) continue; this.employment[popType._id] = (this.employment[popType._id] ?? 0) + amount; } // Special getModifiersAsIO("state_infrastructure_", "infrastructure"); getModifiersAsIO("country_bureaucracy_", "bureaucracy"); getModifiersAsIO("state_tax_capacity_", "tax_capacity"); getModifiersAsIO("country_convoys_capacity_", "convoys_capacity"); surfaceProperties(this, "employmentCount", "nonZeroOutputs", "nonZeroInputs", "nonZeroGoods"); } get employmentCount() { return Object.values(this.employment).reduce((total, a) => total + a, 0) } get nonZeroOutputs() { return Object.entries(this.outputs).filter(e => e[1] != 0).map(e => e[0]); } get nonZeroInputs() { return Object.entries(this.inputs).filter(e => e[1] != 0).map(e => e[0]); } get nonZeroGoods() { return _.uniq([...this.nonZeroInputs, ...this.nonZeroOutputs]); } outputPct(goodId) { let positiveOutputVolume = Object.values(this.outputs).filter(a => a > 0).reduce((a,b) => a + b, 0) ?? 0; let outputQty = this.outputs[goodId] ?? 0; // Return undefined if there are no positive outputs at all if (positiveOutputVolume <= 0) return undefined; // Return 0 if there's at least one positive output, but it's not this goodId if (outputQty <= 0) return 0; return outputQty / positiveOutputVolume; } combine(otherPm) { let result = new ProductionMethod(); result.inputs = sumItems(this.inputs, otherPm.inputs); result.outputs = sumItems(this.outputs, otherPm.outputs); result.employment = sumItems(this.employment, otherPm.employment); result.id = [this.id, otherPm.id].filter(id => id).join(", "); let eraNums = [this.era, otherPm.era] .filter(era => era) .map(era => getEraNum(era)); result.era = getEraName(Math.max(0, ...eraNums)); return result; } scale(scalar = 1) { if (correctPrecision(scalar) == 1) return this.copy(); let result = new ProductionMethod(); ["inputs", "outputs", "employment"].forEach(field => result[field] = scaleItems(this[field], scalar)); result.id = `${this.id} x${scalar}`; result.era = this.era; return result; } copy() { let result = new ProductionMethod(); Object.assign(result, _.cloneDeep(this)); return result; } forSingleOutput(goodId, defaultOutputPct = 0) { let result = new ProductionMethod(); result.id = `[${this.id}].forSingleOutput(${goodId})`; result.era = this.era; Object.assign(result, { unlockingPms: [...this.unlockingPms], unlockingLaws: [...this.unlockingLaws], disallowingLaws: [...this.disallowingLaws] }); let outputPct = this.outputPct(goodId) ?? defaultOutputPct; if (outputPct == 0) return result; ["inputs", "employment"].forEach(field => result[field] = scaleItems(this[field], outputPct)); for (let [outputId, amount] of Object.entries(this.outputs)) { if (outputId == goodId) { result.outputs[outputId] = this.outputs[goodId]; } else if (amount < 0) { result.outputs[outputId] = this.outputs[outputId] * outputPct; } } return result; } getNetProduction() { let net = _.clone(this.outputs) Object.keys(this.inputs).forEach(g => net[g] = (net[g] ?? 0) - this.inputs[g]); return net; } } return ProductionMethod; }61:Tadb,NeedSpend = { function add(target, a, b, fields) { let allFieldsPresent = _.union(Object.keys(a), Object.keys(b)); let fieldsToMerge = fields ? _.intersection(fields, allFieldsPresent) : allFieldsPresent; for (let field of fieldsToMerge) { target[field] = (a[field] ?? 0) + (b[field] ?? 0); } } let goodCosts = Object.values(goods) .filter(g => g.category != "hack") .map(g => [g.id, g.cost]); goodCosts = Object.fromEntries(goodCosts); class NeedSpend { constructor() { this.hackGoodConsumption = { infrastructure: 0, tax_capacity: 0, bureaucracy: 0 }; surfaceProperties(this, "totalSpend"); } get needIds() { return _.intersection(Object.keys(this), Object.keys(common.pop_needs)); } get totalSpend() { if (this.needIds.length == 0) return 0; return correctPrecision(_.sum(this.needIds.map(needId => this[needId]))); } combine(otherBp) { let result = new NeedSpend(); add(result, this, otherBp, Object.keys(common.pop_needs)) add(result.hackGoodConsumption, this.hackGoodConsumption, otherBp.hackGoodConsumption) return result; } scale(scalar = 1) { let result = new NeedSpend(); Object.assign(result, _.cloneDeep(this)); if (scalar == 1) return result; for (let needId of result.needIds) { result[needId] = correctPrecision(result[needId] * scalar); } for (let goodId of Object.keys(result.hackGoodConsumption)) { result.hackGoodConsumption[goodId] = correctPrecision(result.hackGoodConsumption[goodId] * scalar); } return result; } getConsumptionVolumes(popConsumptionRates) { let goodsSpend = {}; for (let [needId, goodConsumptionRates] of Object.entries(popConsumptionRates)) { let needSpend = this[needId] ?? 0; if (!needSpend) continue; for (let [goodId, consumptionRate] of Object.entries(goodConsumptionRates)) { consumptionRate = correctPrecision(consumptionRate); if (!consumptionRate) continue; goodsSpend[goodId] ??= 0; goodsSpend[goodId] += correctPrecision(needSpend * consumptionRate); } } let volumeEntries = []; for (let [goodId, spend] of Object.entries(goodsSpend)) { volumeEntries.push([goodId, spend / goodCosts[goodId]]); } volumeEntries = volumeEntries.concat(Object.entries(this.hackGoodConsumption)) volumeEntries.forEach(e => e[1] = correctPrecision(e[1])); volumeEntries = volumeEntries.filter(e => e[1]); volumeEntries = _.sortBy(volumeEntries, e => Object.keys(goods).indexOf(e[0])); return Object.fromEntries(volumeEntries); } } return NeedSpend; }62:T603,PopType = { // Constants const workersPerBuyPackage = common.defines.NPops.POP_SIZE_PACKAGE; const dependentConsumptionRatio = common.defines.NPops.DEPENDENT_CONSUMPTION_RATIO; class PopType { static { PopType.workersPerBuyPackage = workersPerBuyPackage; } constructor(popDefOrString) { if (!popDefOrString) return; let popDef = (typeof(popDefOrString) == "string") ? common.pop_types[popDefOrString] : popDefOrString; this.id = popDef._id; this.wealthLevel = popDef.start_quality_of_life; this.workingAdultRatio = popDef.working_adult_ratio ?? common.defines.NPops.WORKING_ADULT_RATIO_BASE; this.consumptionMult = popDef.consumption_mult ?? 1; this.dependentWage = popDef.dependent_wage this.wageWeight = popDef.wage_weight; surfaceProperties(this); } get individualsPerBuyPackage() { return Math.round(workersPerBuyPackage / this.workingAdultRatio); } get dependentsPerBuyPackage() { return Math.round(this.individualsPerBuyPackage - workersPerBuyPackage); } get dependentsPerWorkingAdult() { return correctPrecision(this.dependentsPerBuyPackage / workersPerBuyPackage); } get wageRate() { return correctPrecision(1 + this.dependentsPerWorkingAdult * this.dependentWage); } get consumptionRate() { let unscaledRate = 1 + this.dependentsPerWorkingAdult * dependentConsumptionRatio; return correctPrecision(this.consumptionMult * unscaledRate); } } return PopType; }63:Tcd4,getPopConsumptionRanges = { let bpNeedsOrder = {}; Object.values(common.buy_packages).forEach((bp, i) => { for (let need of Object.keys(bp.goods)) { bpNeedsOrder[need] ??= {}; bpNeedsOrder[need].first ??= i; bpNeedsOrder[need].last = i; } }); let defaults = { producableGoods, availableGoods }; function getPopConsumptionRanges(availableGoods) { let popConsumptionRanges = {} for (let [name, need] of Object.entries(common.pop_needs)) { let entryDefs = need.entry.filter(e => availableGoods.includes(e.goods)); if (entryDefs.length == 1) entryDefs = [{ goods: entryDefs[0].goods, weight: 1, max_weight: 5, min_weight: 5 }]; entryDefs = entryDefs.filter(e => availableGoods.includes(e.goods)); if (entryDefs.length == 0) { popConsumptionRanges[name] = undefined; continue; } let rangeEntries = []; let sumOfWeights = entryDefs.reduce((sum, e) => sum + e.weight, 0); for (let entryDef of entryDefs) { rangeEntries.push([ entryDef.goods, { weight: entryDef.weight / sumOfWeights, spendPctRange: [ Math.max(0, 0.2 * entryDef.min_weight / entryDef.weight), Math.min(1, 0.2 * entryDef.max_weight / entryDef.weight) ] } ]); } rangeEntries = _.sortBy(rangeEntries, [e => 1 - e[1].weight, e => e[1].unitCost, e => e[0]]) rangeEntries.forEach(e => correctPrecision(e[1].spendPctRange)); popConsumptionRanges[name] = Object.fromEntries(rangeEntries); } // Within each need, make each good's mins and maxes mutually compatible. // (popneed_crude_items has two goods, both with a max of 0.8 and a min of 0. This // loop shifts both mins to 0.2.) for (let [needId, needGoods] of Object.entries(popConsumptionRanges).filter(e => e[1])) { let ranges = Object.values(needGoods).map(g => g.spendPctRange); let allMins = ranges.map(r => r[0]); let allMaxes = ranges.map(r => r[1]); Object.entries(needGoods).forEach(([goodId, good], i) => { let range = ranges[i]; let otherMaxes = allMaxes.filter((m,j) => i != j); let otherMins = allMins.filter((m,j) => i != j); let min = Math.max(range[0], correctPrecision(1 - _.sum(otherMaxes))); let max = Math.min(range[1], correctPrecision(1 - _.sum(otherMins))); popConsumptionRanges[needId][goodId].spendPctRange = [min, max]; }); } return sortObjectByKeys(popConsumptionRanges, [ n => bpNeedsOrder[n].first, n => bpNeedsOrder[n].last ]); } function getPopConsumptionRangesWithFallback(producableGoods = defaults.producableGoods, importableGoods = defaults.importableGoods) { let popNeeds = getPopConsumptionRanges(producableGoods); if (!importableGoods?.length) return popNeeds; if (Object.values(popNeeds).every(g => g)) return popNeeds; let availableGoods = _.uniq(producableGoods.concat(importableGoods)) let popNeedsWithImports = getPopConsumptionRanges(availableGoods); Object.keys(popNeeds).forEach(needId => popNeeds[needId] ??= popNeedsWithImports[needId]); return popNeeds; } return getPopConsumptionRangesWithFallback; }64:T14a2,productionMethodSelections = { function getLegalPmSelections(buildingId) { let building = common.buildings[buildingId]; let pmgs = building.production_method_groups.map(id => common.production_method_groups[id]); let pmgPms = []; for (let pmg of pmgs) { let pms = pmg.production_methods.map(pm => productionMethods[pm]); if (pms.length) pmgPms.push(pms); } let pmSelections = d3.cross(...pmgPms); let legalPmSelections = []; for (let pms of pmSelections) { let selectedPmIds = pms.map(pm => pm.id); let unlockingPmIdSets = pms.map(pm => pm.unlockingPms); let conditionsMet = unlockingPmIdSets.map(set => set.length == 0 || set.some(id => selectedPmIds.includes(id))); let isLegal = conditionsMet.reduce((legal, met) => legal && met, true); if (!isLegal) continue; legalPmSelections.push(pms); } return legalPmSelections; } let pmSelections = []; // Build normal pmSelections for (let [buildingId, building] of Object.entries(buildings)) { if (!common.buildings[buildingId]) continue; if (!relevantBuildings.includes(buildingId)) continue; for (let pms of getLegalPmSelections(buildingId)) { let combinedPm = pms.reduce((combined, pm) => combined.combine(pm), new ProductionMethod()); combinedPm.inputs.infrastructure = building.infrastructure_usage; if (buildingId == "building_trade_center") { combinedPm.outputs["trade_route_levels"] = 1; } if (buildingId == "building_urban_center") { combinedPm.outputs["urbanization"] = common.defines.NEconomy.URBANIZATION_PER_BUILDING; } else { combinedPm.inputs["urbanization"] = building.urbanization; } let hasOutput = Object.values(combinedPm.outputs).filter(o => o).length > 0; if (!hasOutput) continue; let option = { building: buildingId }; ["inputs", "outputs", "employment"].forEach(field => { option[field] = Object.entries(combinedPm[field] ?? {}).filter(e => e[1] != 0).map(e => e[0]); }); option.combinedPm = combinedPm; option.combinedPm.id = `${buildingId}[${combinedPm.id}]`; option.selectedPms = pms; option.unlockingLaws = _.sortBy(_.uniq(pms.flatMap(pm => pm.unlockingLaws))); option.disallowingLaws = _.sortBy(_.uniq(pms.flatMap(pm => pm.disallowingLaws))); option.buildingAndPmEraNum = Math.max(...[0, building.era, ...pms.map(pm => getEraOf(pm))].map(era => getEraNum(era))); option.id = option.combinedPm.id; pmSelections.push(option); }; } // build trade route pmSelections for (let pm of Object.values(tradeRouteProductionMethods)) { let combinedPm = pm.copy(); combinedPm.inputs.infrastructure = 0; combinedPm.inputs.urbanization = 0; let option = { building: "_trade_route" }; ["inputs", "outputs", "employment"].forEach(field => { option[field] = Object.entries(combinedPm[field] ?? {}).filter(e => e[1] != 0).map(e => e[0]); }); option.isTrade = pm.isTrade; option.combinedPm = combinedPm; option.combinedPm.id = `${option.building}[${combinedPm.id}]`; option.selectedPms = [pm]; option.unlockingLaws = pm.unlockingLaws; option.disallowingLaws = pm.disallowingLaws; option.buildingAndPmEraNum = 0; option.id = option.combinedPm.id; pmSelections.push(option); } let setEra = (map, dir, key, newValue) => { if (newValue === undefined) { let e = new Error("called setEra with undefined"); console.log(e); throw e; } let currentValue = map.get(key); if (dir == "max" && currentValue >= newValue) return false; if (dir == "min" && currentValue <= newValue) return false; map.set(key, newValue); return true; }; let setEraToMin = (map, key, value) => setEra(map, "min", key, value); let setEraToMax = (map, key, value) => setEra(map, "max", key, value); let incrementEra = (map, key) => setEra(map, "max", key, (map.get(key) ?? 0) + 1); // initialize pmsEras with buildingAndPmEraNum let pmsEras = new Map(Object.values(pmSelections).map(pms => [pms, pms.buildingAndPmEraNum])); let loopCount = 0; function updatePmEras() { loopCount++; if (loopCount > 10) throw "fuck"; let hasChanges = false; // set goodEras to the era of the earliest pms that can produce it let goodEras = new Map(); for (let pms of pmSelections) { let pmsEra = pmsEras.get(pms); for (let output of pms.outputs) { setEraToMin(goodEras, output, pmsEra); } } hackGoods.forEach(g => setEraToMin(goodEras, g, 0)); // update pmsEras to the first era where all their inputs are available // TODO: Handle unavailable pop types under isolationism for (let pms of pmSelections) { let pmsEra = pmsEras.get(pms); for (let input of pms.inputs) { hasChanges = setEraToMax(pmsEras, pms, goodEras.get(input)) || hasChanges; } } return hasChanges; } while (updatePmEras()); pmSelections for (let pms of pmSelections) { pms.era = getEraName(pmsEras.get(pms)); delete pms.buildingAndPmEraNum; } return _.sortBy(pmSelections, [ "building", "era", "id" ]); }65:T576,tradeRouteProductionMethods = { let tradeableGoods = {}; for (let [goodId, goodDef] of Object.entries(common.goods)) { let tmp = Object.assign({ tradeable: true }, goodDef); if (!tmp.tradeable) continue; tradeableGoods[goodId] = { traded_quantity: goodDef.traded_quantity ?? common.defines.NEconomy.TRADE_ROUTE_DEFAULT_GOODS_QUANTITY, convoy_cost_multiplier: goodDef.convoy_cost_multiplier ?? common.defines.NEconomy.GOODS_DEFAULT_CONVOY_COST_MULTIPLIER }; } let tradeRoutePms = {}; // because it doesn't scale by trade route level, the trade_routes good is created by the model itself, lol let bcPm = new ProductionMethod(); bcPm.id = "trade_route_bureaucracy_cost"; bcPm.isTrade = false; bcPm.inputs.bureaucracy = common.defines.NEconomy.TRADE_ROUTE_BUREAUCRACY_COST; bcPm.outputs.trade_routes = 1; bcPm.disallowingLaws.push("law_isolationism"); tradeRoutePms[bcPm.id] = bcPm; for (let [goodId, good] of Object.entries(tradeableGoods)) { let pm = new ProductionMethod(); pm.id = `trade_route_${goodId}`; pm.isTrade = true; pm.inputs.convoys_capacity = correctPrecision(good.traded_quantity * good.convoy_cost_multiplier); pm.inputs.trade_route_levels = 1; pm.outputs[goodId] = good.traded_quantity; pm.disallowingLaws.push("law_isolationism"); tradeRoutePms[pm.id] = pm; } return tradeRoutePms; }66:T719,goods = { let mt = common.modifier_types; let hackGoodPrices = { convoys_capacity: mt.country_convoys_capacity_add.ai_value, infrastructure: mt.state_infrastructure_add.ai_value, bureaucracy: mt.country_bureaucracy_add.ai_value } let goods = {}; function getGood(goodId) { let goodDef = common.goods[goodId]; if (goodDef) goodDef = Object.assign({ tradeable: true }, goodDef); goods[goodId] ??= { id: goodId, productionMethodSelections: [], cost: goodDef?.cost, category: goodDef?.category, tradeable: !!goodDef?.tradeable, }; if (goodDef?.tradeable) { goods[goodId].traded_quantity = goodDef.traded_quantity ?? common.defines.NEconomy.TRADE_ROUTE_DEFAULT_GOODS_QUANTITY; goods[goodId].convoy_cost_multiplier = goodDef.convoy_cost_multiplier ?? common.defines.NEconomy.GOODS_DEFAULT_CONVOY_COST_MULTIPLIER; } if (hackGoods.includes(goodId)) { goods[goodId].cost = hackGoodPrices[goodId]; goods[goodId].category = "hack"; } return goods[goodId]; } for (let pms of productionMethodSelections.filter(pms => !pms.isTrade)) { for (let goodId of Object.keys(pms.combinedPm.outputs)) { let good = getGood(goodId); good.productionMethodSelections.push(pms); } } for (let goodId of hackGoods.filter(g => !Object.keys(goods).includes(g))) { goods[goodId] = {}; } for (let good of Object.values(goods)) { let allEraNums = _.uniq(good.productionMethodSelections?.map(pms => getEraNum(pms.era))); if (allEraNums.length == 0) allEraNums = [0]; good.era = getEraName(Math.min(...allEraNums)); } let entries = Object.entries(goods); entries = _.sortBy(entries, [e => hackGoods.includes(e[0]), 0]); return Object.fromEntries(entries); }67:T6a5,buildings = { function getBuildingAttributes(buildingOrGroupOrId) { if (!buildingOrGroupOrId) return []; let obj = buildingOrGroupOrId; if (typeof(buildingOrGroupOrId) == "string") { obj = common.buildings[buildingOrGroupOrId] ?? common.building_groups[buildingOrGroupOrId] ?? buildingOrGroupOrId; } let attrs = _.pick(obj, ["infrastructure_usage_per_level", "is_subsistence", "urbanization", "category", "lens"]); attrs.building_groups = [obj.building_group ?? obj.parent_group].filter(g => g); let parentId = obj.building_group ?? obj.parent_group; if (parentId) { let parentAttrs = getBuildingAttributes(parentId); attrs.building_groups.push(...parentAttrs.building_groups); attrs = Object.assign(parentAttrs, attrs); } return attrs; } let buildings = {}; for (let buildingId of Object.keys(common.buildings)) { let building = getBuildingAttributes(buildingId); building.id = buildingId; building.is_subsistence ??= false; building.urbanization ??= 0; building.infrastructure_usage_per_level ??= 0; building.era = getEraOf(buildingId); if (building.is_subsistence) building.infrastructure_usage_per_level = 0; building.infrastructure_usage = building.infrastructure_usage_per_level; delete building.infrastructure_usage_per_level; building.is_relevant = building.category !== undefined && building.lens != "special"; buildings[buildingId] = building; } buildings._trade_route = { id: "_trade_route", building_groups: [], urbanization: 0, era: 'era_0', infrastructure_usage: 0, is_relevant: true } return sortObjectByKeys(buildings); }68:T9f9,laws = { let lawPmImpacts = Object.entries(common.production_methods) .map(e => [e[0], (e[1].unlocking_laws ?? []).concat(e[1].disallowing_laws ?? [])]) .flatMap(e => e[1].map(lawId => [e[0], lawId])); lawPmImpacts = _.groupBy(lawPmImpacts, 1); Object.keys(lawPmImpacts).forEach(lawId => lawPmImpacts[lawId] = lawPmImpacts[lawId].map(e => e[0])); let impactedPms = _.uniq(Object.values(lawPmImpacts).flat()); let impactedPmBuildings = Object.fromEntries(impactedPms.map(pm => [pm, []])); for (let building of Object.values(common.buildings)) { for (let pmg of building.production_method_groups.map(pmg => common.production_method_groups[pmg])) { for (let pm of _.intersection(impactedPms, (pmg.production_methods ?? []))) { impactedPmBuildings[pm].push(building._id); } } } let lawModifierImpacts = Object.entries(common.laws) .map(e => [e[0], _.intersection(knownModifierIds, Object.keys(e[1].modifier ?? []))]) .filter(e => e[1].length); lawModifierImpacts = Object.fromEntries(lawModifierImpacts); let lawImpacts = {}; for (let [lawId, law] of Object.entries(common.laws)) { let pms = (lawPmImpacts[lawId] ?? []); let buildings = pms.flatMap(pm => impactedPmBuildings[pm]); let modifiers = (lawModifierImpacts[lawId] ?? []); let counts = { pms: _.uniq(pms).length, buildings: _.uniq(buildings).length, modifiers: _.uniq(modifiers).length, } if (_.sum(Object.values(counts))) lawImpacts[lawId] = counts; } let lawCategories = _.uniq(Object.values(common.law_groups).map(lg => lg.law_group_category)); let lawGroups = Object.keys(common.law_groups); let lawIds = Object.keys(common.laws); function getSortNum(law) { try { return 10000000 * (1 + lawCategories.indexOf(law.category)) + 100000 * (1 + lawGroups.indexOf(law.group)) + 100 * (1 + common.laws[law.id].progressiveness) + (1 + lawIds.indexOf(law.id)); } catch (e) { console.log(law, e) throw e; } } let laws = {}; for (let [lawId, law] of Object.entries(common.laws)) { let lawDef = common.laws[lawId]; laws[lawId] = { id: lawId, category: common.law_groups[lawDef.group].law_group_category, group: lawDef.group, era: getEraOf(lawDef), modifier: getKnownModifiers(lawDef), unlockingLaws: lawDef.unlocking_laws ?? [], disallowingLaws: lawDef.disallowing_laws ?? [], unlocks: lawImpacts[lawId] }; } return sortObjectBy(laws, l => getSortNum(l)); }69:T656,states = { function add(target, field, value) { target[field] ??= 0; target[field] += value; } let states = {}; for (let [stateId, stateDef] of Object.entries(common.map_data.state_regions)) { if (!stateDef.arable_land) continue; let state = states[stateId] = { _id: stateId, maxBuildings: {}, maxBuildingGroups: {} }; // populate maxBuildings add(state.maxBuildings, stateDef.subsistence_building, stateDef.arable_land); for (let building of stateDef.arable_resources ?? []) { add(state.maxBuildings, building, stateDef.arable_land); } // populate maxBuildingGroups add(state.maxBuildingGroups, "_arable_resources", stateDef.arable_land); for (let [bg, cap] of Object.entries(stateDef.capped_resources ?? {})) { add(state.maxBuildingGroups, bg, cap); } for (let r of (state.resource ?? [])) { add(state.maxBuildingGroups, r.type, r.undiscovered_amount); } } // add state population data for (let [nsStateId, popHistory] of Object.entries(common.history.pops)) { let state = states[nsStateId.split(":").pop()]; let createPopEntries = Object.keys(popHistory) .filter(k => k.startsWith("region_state:")) .map(k => popHistory[k]) .flatMap(rs => rs.create_pop); state.population = createPopEntries.reduce((sum, e) => sum + e.size, 0); } // add state homeland data for (let [nsStateId, stateHistory] of Object.entries(common.history.states)) { let state = states[nsStateId.split(":").pop()]; state.cultures = stateHistory.add_homeland ?? []; } return states; }6a:T15ad,countries = { function add(target, field, value) { target[field] ??= 0; target[field] += value; } /* 1. Build countries from country_definitions */ let countries = {}; for (let [countryId, countryDef] of Object.entries(common.country_definitions)) { countries[countryId] = { id: countryId, name: loc.tryGetText(countryId), isDecentralized: countryDef.country_type == "decentralized", type: undefined, tier: countryDef.tier, cultures: [...countryDef.cultures], states: [] } } /* 2. State-to-country mapping */ // historical countries for (let [nsStateId, stateHistory] of Object.entries(common.history.states)) { let state = states[nsStateId.split(":").pop()]; for (let nsCountryId of stateHistory.create_state.map(c => c.country)) { let country = countries[nsCountryId.split(":").pop()]; if (!country) continue; country.type = "historical"; country.states.push(state); } } // releasable / formable countries let ccLoopParams = [ { type: "releasable", source: common.country_creation }, { type: "formable", source: common.country_formation } ] for (let { type, source } of ccLoopParams) { for (let [countryId, formationDef] of Object.entries(source)) { let country = countries[countryId]; country.isDecentralized = false; if (country.type == "historical") continue; country.type = type; if (formationDef.use_culture_states) { for (let culture of country.cultures) { country.states.push(...Object.values(states).filter(s => s.cultures.includes(culture))); } } else if (formationDef.states) { country.states.push(...formationDef.states.map(stateId => states[stateId])); } } } /* 3. Country data aggregation */ countries = Object.values(countries).filter(c => !c.isDecentralized && c.states.length); for (let country of countries) { country.maxBuildings = Object.fromEntries(buildingGroups._arable_resources.map(b => [b, 0])); country.maxBuildingGroups = {}; country.population = 0; for (let state of _.uniq(country.states)) { for (let [building, amount] of Object.entries(state.maxBuildings)) { add(country.maxBuildings, building, amount); } for (let [buildingGroup, amount] of Object.entries(state.maxBuildingGroups)) { add(country.maxBuildingGroups, buildingGroup, amount); } country.population += state.population; } delete country.states; delete country.isDecentralized; } /* 4. Sorting */ countries = _.sortBy(countries, [c => 1000 - tierPrestige[c.tier], c => c.type != "historical", "name", "id"]) countries = Object.fromEntries(countries.map(c => [c.id, c])); return countries; /* 2. States */ /* add(country.maxBuildings, state.subsistence_building, state.arable_land); _.pick(stateDef, ["susbsistence_building", "arable_land"]); state._id = stateId; id: countryId, ara: undefined, tier: countryDef.tier, isDecentralized: countryDef.country_type == "decentralized", cultures: [...countryDef.cultures], states: [] } country.population += state.population; add(country.maxBuildings, state.subsistence_building, state.arable_land); for (let building of state.arable_resources ?? []) { add(country.maxBuildings, building, state.arable_land); } } for (let [nsStateId, stateDef] of Object.entries(common function addState(countryId, state) // common.history.states: states at game start for (let [nsStateId, stateDef] of Object.entries(common.history.states)) { let stateId = nsStateId.split(":").pop(); for (let nsCountryId of stateDef.create_state.map(c => c.country)) { let countryId = nsCountryId.split(":").pop(); let country = countries[countryId]; country.type = "initial"; let mapData = _.pick(common.map_data.state_regions[stateId], mapDataFields); let state = _.cloneDeep(mapData); state.id = stateId; let nsRegionStateId = nsCountryId.replace("c:", "region_state:"); let regionStateDef = common.history.pops[nsStateId][nsRegionStateId]; state.population = regionStateDef.create_pop.reduce((sum, cp) => sum + cp.size, 0); country.states.push(state); } } for (let [countryId, releasable] of Object.entries(common.country_creation)) { \country_creation } for (let [countryId, country] of Object.entries(countries)) { let countryDef = common.country_definitions[countryId]; country.population = 0; country.maxBuildings = {}; country.maxBuildingGroups = {}; for (let state of country.states) { country.population += state.population; add(country.maxBuildings, state.subsistence_building, state.arable_land); for (let building of state.arable_resources ?? []) { add(country.maxBuildings, building, state.arable_land); } add(country.maxBuildingGroups, "_arable_resources", state.arable_land); for (let [bg, cap] of Object.entries(state.capped_resources ?? {})) { add(country.maxBuildingGroups, bg, cap); } for (let r of (state.resource ?? [])) { add(country.maxBuildingGroups, r.type, r.undiscovered_amount); console.log('resource', r); } } } // countries = Object.fromEntries(Object.entries(countries).filter return countries; */ }6b:T715,buildingModifiers = { let specs = Object.assign({}, hackBuildingModifierSpecs, autoBuildingModifierSpecs); let applyMult = (obj, field, value) => { if (!obj[field]) return; obj[field] = correctPrecision(obj[field] * (1 + value)); } let buildingModifiers = {}; for (let [modifierId, spec] of Object.entries(specs)) { let modifier = { id: modifierId, } // Surface values for debug / sanity checking if (spec.type) modifier.type = spec.type; if (spec.good) modifier.good = spec.good; // Buildings (if any) if (spec.buildings) modifier.buildings = spec.buildings if (spec.building_group) { modifier.buildings = buildingGroups[spec.building_group]; } // Define the function that will apply the modifier to the PM let functionsToApply = []; modifier.apply = (pm, value) => { functionsToApply.forEach(fn => fn(pm, value)); }; // Employee if (spec.type == "employee") { functionsToApply.push((pm, value) => { Object.keys(pm.employment).forEach(popType => applyMult(pm.employment, popType, value)); }); } // Input, output, throughput let singleGoodId = spec.good; let loopParams = [ { types: ["input", "throughput"], field: "inputs" }, { types: ["output", "throughput"], field: "outputs" } ]; for (let {types, field} of loopParams) { if (types.includes(spec.type)) { let fn; if (singleGoodId) { fn = (pm, value) => applyMult(pm[field], singleGoodId, value); } else { fn = (pm, value) => Object.keys(pm[field]).forEach(goodId => applyMult(pm[field], goodId, value)); } functionsToApply.push(fn); } } buildingModifiers[modifier.id] = modifier; } return buildingModifiers; }6c:T812,autoBuildingModifierSpecs = { let tokenSets = { flag: ["building_group"], building_group: Object.keys(common.building_groups), buildings: ["building", ...Object.keys(common.buildings)], good: ["radio", ...Object.keys(common.goods), ...hackGoods], type: ["input", "output", "throughput", "employee"], op: ["add", "mult"] } for (let [set, tokens] of Object.entries(tokenSets)) { tokenSets[set] = _.sortBy(tokens, [t => 1000 - t.length, t => t]); } function parseModifier(remainingId, result = { id: remainingId, ignored: [], }, nextType) { let match, matchType; let sets = (nextType) ? [nextType] : Object.keys(tokenSets); for (let set of sets) { if (!tokenSets[set]) return { remainingId, result, sets, set }; match = tokenSets[set].find(t => remainingId.startsWith(t)); if (match) { matchType = set; break; } } if (!match) { if (sets.length != Object.keys(tokenSets).length) { throw `${result.id}: Match for ${remainingId} not found in ${sets.join(", ")}`; } let underscoreIndex = remainingId.indexOf("_"); match = (underscoreIndex == -1) ? remainingId : remainingId.slice(0, underscoreIndex); result.ignored.push(match); } nextType = undefined; if (matchType) { if (matchType == "op") {} else if (matchType == "flag") { nextType = match; } else if (matchType == "buildings") { if (match != "building") { result.buildings = (result.buildings ?? []); result.buildings.push(match); } } else { result[matchType] = (match == "radio") ? "radios" : match; } } remainingId = remainingId.slice(match.length + 1); if (remainingId.length == 0) { if (!result.ignored.length) delete result.ignored; return result; } return parseModifier(remainingId, result, nextType); } let result = {} for (let id of autoBuildingModifierIds) { result[id] = parseModifier(id); } return result; }6d:T415,getEraOf = { let cache = new Map(); function findEraOf(objOrString) { let obj = (typeof(objOrString) == "string") ? common.find(objOrString) : objOrString; if (!obj) return; let eras = [obj.era ?? "era_0"]; if (Array.isArray(obj.unlocking_technologies)) { eras = eras.concat(obj.unlocking_technologies.map(t => getEraOf(common.technologies[t]))); } if (Array.isArray(obj.unlocking_production_methods)) { eras = eras.concat(obj.unlocking_production_methods.map(p => getEraOf(common.production_methods[p]))); } if (Array.isArray(obj.unlocking_laws)) { eras = eras.concat(obj.unlocking_laws.map(l => getEraOf(common.laws[l]))); } eras.sort(); return eras.pop(); } function getEraOf(objOrString) { let id = objOrString?._id ?? objOrString; if (typeof(id) != "string") return findEraOf(objOrString); if (!cache.has(id)) { let era = findEraOf(objOrString); if (era) cache.set(id, era); } return cache.get(id); } return getEraOf; }6e: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 = /(?