25:["$","title",null,{"children":"Victoria 3 resource glpk v5.6 | mheard03 | Observable"}] 49:T543,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 label = `${loc.tryGetText(l.id)} (${l.unlocks.pms} PMs, ${l.unlocks.buildings} buildings)`; 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.unshift(html`

Laws`); formElements = formElements.map(e => Object.assign(e, { style: '--label-width: 150px; --input-width: 300px' })) return Inputs.form(formElements); }4a: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")}`; }4b: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; }4c: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}; */ }4d: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) { } } */ 4e: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" } } */4f: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 } };50: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; }51: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; }52:Tca1,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")]; 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 = popTypeConsumption[popType].scale(count / PopConsumption.defaultSize); 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; }53:Ted4,solutionGoods = { let usedGoods = [...popGoods, ...solutionPmSelections.flatMap(pms => pms.combinedPm.nonZeroGoods)] usedGoods = _.uniq(usedGoods); let militaryGoods = usedGoods.filter(g => goods[g].category == "military"); let globalUsageGoods = usedGoods.filter(g => solutionPmSelections.every(pms => pms.combinedPm.nonZeroGoods.includes(g))); let noFollowGoods = _.uniq(["transportation", ...hackGoods, ...globalUsageGoods]); function getAllLinkedGoods(rootGood, fnGetNextLinkedGoods) { 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; } function getDownstreamGoods(rootGood) { let getOutputs = (good) => { let goods = solutionPmSelections.filter(pms => pms.inputs.includes(good)).flatMap(pms => pms.outputs); goods = _.uniq(goods); return { follow: _.difference(goods, noFollowGoods), noFollow: _.intersection(goods, noFollowGoods) } }; return getAllLinkedGoods(rootGood, getOutputs); } function getUpstreamGoods(rootGood) { let getInputs = (good) => { let goods = solutionPmSelections.filter(pms => pms.outputs.includes(good)).flatMap(pms => pms.inputs); goods = _.uniq(goods); return { follow: _.difference(goods, noFollowGoods), noFollow: _.intersection(goods, noFollowGoods) } }; return getAllLinkedGoods(rootGood, getInputs); } let result = {}; for (let good of usedGoods) { let goodInfo = { id: good, downstreamGoods: getDownstreamGoods(good), upstreamGoods: getUpstreamGoods(good), tags: new Set(), hasCycle: false, }; // Cycles if (goodInfo.upstreamGoods.includes(good)) { goodInfo.hasCycle = true; if (hackGoods.includes(good)) { goodInfo.cycleSet = "hack"; } else { goodInfo.cycleSet = _.sortBy(goodInfo.upstreamGoods.filter(g => !noFollowGoods.includes(g))).join("|"); } } // Tags if (hackGoods.includes(good)) goodInfo.tags.add("hack"); if (popGoods.includes(good)) goodInfo.tags.add("consumer"); if (militaryGoods.includes(good)) goodInfo.tags.add("military"); if (goodInfo.downstreamGoods.length == 0) { goodInfo.tags.add("terminal") } else { if (_.intersection(goodInfo.downstreamGoods, popGoods).length) goodInfo.tags.add("consumer_input"); if (_.intersection(goodInfo.downstreamGoods, militaryGoods).length) goodInfo.tags.add("military_input"); if (goodInfo.downstreamGoods.length == usedGoods.length) goodInfo.tags.add("global_input"); } let buildingRurality = solutionPmSelections.filter(pms => pms.outputs.includes(good)) .map(pms => pms.building) .map(b => buildings[b].category == "rural"); buildingRurality = _.uniq(buildingRurality); if (buildingRurality.length == 1 && buildingRurality[0]) goodInfo.tags.add("rural"); result[good] = goodInfo; } Object.values(result).forEach(r => r.tags = [...r.tags]); return result; return Object.values(result).filter(r => r.tags.has("consumer_input") && r.tags.has("military_input") && !r.tags.has("global_input")); return Object.values(result).filter(r => r.tags.size == 1); }54:T525,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 = availableGoods.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; }55:Td04,glpkNamer = { 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(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"].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 = ["pmsId", "popType", "needId", "goodId", "goodFlag", "needFlag"] .map(t => params[t]) .concat(params.suffixes) .filter(t => t); if (tokens.length == 0) { throw ({paramsOrArray, params, array}); } return tokens.join("|"); } return { readName, getName }; }56: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 }57:T4c8,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) { if (buildings[pms.building].is_subsistence) continue; 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; }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:T29a1,function getProblemSubjectTo(target, ) { target ??= problemTarget; let popTypesUsed = _.uniq(availablePmSelections.flatMap(pms => pms.employment)); let popNeeds = getPopNeeds(producableGoods); // TODO: Calculate/guesstimate "cost" of hackGoods // TODO: Calculate tax capacity "cost" dynamically? function getOrCreateBalancingConstraintNamed(...names) { let constraintName; let varName = names; if (varName.length > 1) constraintName = varName.pop(); varName = glpkNamer.getName(varName); constraintName = glpkNamer.getName(constraintName ?? [varName, "def"]); return { name: constraintName, vars: [ { name: varName, coef: -1 } ], bnds: { type: glpk.GLP_FX, lb: 0, ub: 0 } }; } function getOrCreateBalancingConstraint(...varName) { varName = glpkNamer.getName(varName); let constraintName = glpkNamer.getName(`${varName}|def`); return getOrCreateBalancingConstraintNamed(varName, constraintName); } let bounds = [ { name: "constant", type: glpk.GLP_FX, lb: 1 }, { name: glpkNamer.getName("infrastructure", "consumed"), type: glpk.GLP_UP, ub: 0 }, // TODO: Calculate state_tax_capacity_used from modifiers // { name: "state_tax_capacity_used", type: glpk.GLP_DB, lb: 0, ub: solverOptions.stateCount * 100 }, { name: "state_tax_capacity_used", type: glpk.GLP_FX, lb: 0 }, ]; let subjectTo = { goods: {}, goodsOutput: {}, goodsInput: {}, goodsConsumed: {}, popTypes: {}, needSpend: {}, needGoodsSpend: {}, needGoodsSpendPct: {}, needGoodsSpendDev: {}, targets: {}, 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, "input"], -1); setConstraintVar(constraint, [goodId, "consumed"], -1); if (goodId == "tax_capacity") { setConstraintVar(constraint, "state_tax_capacity_used", 1); } } // subjectTo.goodsOutput: Output volumes per pms // subjectTo.goodsInput: Input volumes per pms for (let pms of availablePmSelections) { let combinedPm = pms.combinedPm; for (let goodId of pms.outputs) { // subjectTo.goodsOutput let constraint = subjectTo.goodsOutput[goodId] ??= getOrCreateBalancingConstraint(goodId, "output"); addConstraintVar(constraint, pms.id, combinedPm.outputs[goodId]); } for (let goodId of pms.inputs) { // subjectTo.goodsInput let constraint = subjectTo.goodsInput[goodId] ??= getOrCreateBalancingConstraint(goodId, "input"); addConstraintVar(constraint, pms.id, combinedPm.inputs[goodId]); } } // subjectTo.objectives: Total number of buildings for (let pms of availablePmSelections) { let constraint = subjectTo.objectives["buildings"] ??= getOrCreateBalancingConstraint("buildings"); let coef = 1; if (buildings[pms.building].is_subsistence) coef = solverOptions.subsistenceBuildingWeight; if (pms.building == "building_urban_center") coef = 0; addConstraintVar(constraint, pms.id, coef); } // subjectTo.targets: Special handling for hackGoods for (let [objId, targetQty] of Object.entries(target)) { subjectTo.targets[objId] = { name: glpkNamer.getName(objId, "target"), vars: [{ name: glpkNamer.getName(objId), coef: 1 }], bnds: { type: glpk.GLP_LO, lb: targetQty } }; } // 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 = target[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.popCounts: 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 / PopConsumption.defaultSize; addConstraintVar(constraint, pms.id, numPops); } } // subjectTo.needSpend: Pop spend per need for (let needId of Object.keys(common.pop_needs)) { let constraint = getOrCreateBalancingConstraint(needId, "spend"); for (let [popType, popConsumption] of Object.entries(popTypeConsumption)) { if (popConsumption.needIds.includes(needId)) { addConstraintVar(constraint, popType, popConsumption[needId].needSpend); } } if (constraint.vars.length > 1) subjectTo.needSpend[needId] = constraint; } // 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, rows] of Object.entries(popNeeds)) { let totalSpendName = glpkNamer.getName(needId, "spend"); let totalSpendConstraint = subjectTo.needGoodsSpend[needId] ??= getOrCreateBalancingConstraintNamed(totalSpendName, [totalSpendName, "goods", "def"]); for (let row of rows) { let { good, unitCost, weight, spendPctRange } = row; let goodSpendName = glpkNamer.getName(needId, good, "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, ub: 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 target spend 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, rows] of Object.entries(popNeeds)) { for (let row of rows) { let { good, unitCost, spendPctRange } = row; let goodConsumedName = glpkNamer.getName(good, "consumed"); let constraint = subjectTo.goodsConsumed[good]; if (!constraint) { constraint = subjectTo.goodsConsumed[good] = getOrCreateBalancingConstraint(goodConsumedName); constraint.vars[0].coef = -unitCost; } setConstraintVar(constraint, [needId, good, "spend"], 1); } } // subjectTo.goodsConsumed: Total hackGoods produced or consumed given pop type for (let [popType, popConsumption] of Object.entries(popTypeConsumption)) { for (let [goodId, qty] of Object.entries(popConsumption.hackNeeds)) { let constraint = subjectTo.goodsConsumed[goodId] ??= getOrCreateBalancingConstraint(goodId, "consumed"); addConstraintVar(constraint, popType, qty); } } // bounds: Fix unused goods values at 0 so the model can't just invent a number it likes to fake balance things for (let group of ["output", "input", "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 goods we don't care about (this will usually be one or more hackGoods) let totalSlackConstraint = subjectTo.objectives["slack"] ??= getOrCreateBalancingConstraint("slack"); for (let [goodId, constraint] of Object.entries(subjectTo.goods).filter(e => slackGoods.includes(e[0]))) { 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 = _.sortBy(subjectToArray, e => Object.keys(goods).indexOf(e.name)); return { subjectTo, subjectToArray, bounds }; /* // return subjectTo; return _.sortBy(subjectTo, "name"); */ }5a:T1758,"problemSubjectTo before hackGoods change"; /* problemSubjectTo = { // TODO: HACKGOODS!!! let epsilon = 0.0000000000001; let popTypesUsed = _.uniq(availablePmSelections.flatMap(pms => pms.employment)); let popNeeds = getPopNeeds(producableGoods); function getOrCreateBalancingConstraintNamed(...names) { let constraintName; let varName = names; if (varName.length > 1) constraintName = varName.pop(); varName = glpkNamer.getName(varName); constraintName = glpkNamer.getName(constraintName ?? [varName, "def"]); return { name: constraintName, vars: [ { name: varName, coef: -1 } ], bnds: { type: glpk.GLP_FX, lb: 0, ub: 0 } }; } function getOrCreateBalancingConstraint(...varName) { varName = glpkNamer.getName(varName); let constraintName = glpkNamer.getName(`${varName}|def`); return getOrCreateBalancingConstraintNamed(varName, constraintName); } let subjectTo = { goods: {}, goodsProduced: {}, popTypes: {}, needSpend: {}, needGoodsSpend: {}, needGoodsSpendPct: {}, goodsConsumed: {}, goodsTargets: {}, }; let bounds = [ { name: "constant", type: glpk.GLP_FX, lb: 1 } ]; for (let goodId of availableGoods) { let constraint = subjectTo.goods[goodId] ??= getOrCreateBalancingConstraintNamed(goodId); setConstraintVar(constraint, [goodId, "produced"], 1); setConstraintVar(constraint, [goodId, "consumed"], -1); } // Define goods production and pop type usage based on availablePmSelections for (let pms of availablePmSelections) { // subjectTo.goodsProduced for (let goodId of pms.inputs.concat(pms.outputs)) { let constraint = subjectTo.goodsProduced[goodId] ??= getOrCreateBalancingConstraint(goodId, "produced"); let combinedPm = pms.combinedPm; let numGoods = (combinedPm.outputs[goodId] ?? 0) - (combinedPm.inputs[goodId] ?? 0); addConstraintVar(constraint, pms.id, numGoods); } // subjectTo.popCounts for (let [popType, count] of Object.entries(pms.combinedPm.employment)) { let constraint = subjectTo.popTypes[popType] ??= getOrCreateBalancingConstraint(popType); let numPops = correctPrecision(count / PopConsumption.defaultSize); addConstraintVar(constraint, pms.id, numPops); } } // subjectTo.needSpend: Pop spend per need for (let needId of Object.keys(common.pop_needs)) { let constraint = getOrCreateBalancingConstraint(needId, "spend"); for (let [popType, popConsumption] of Object.entries(popTypeConsumption)) { if (popConsumption.needIds.includes(needId)) { addConstraintVar(constraint, popType, popConsumption[needId].needSpend); } } if (constraint.vars.length > 1) subjectTo.needSpend[needId] = constraint; } // subjectTo.needGoodsSpend: Goods spend per need // subjectTo.needGoodsSpendPct: min and max goods spend per need, sum of total good spend per need for (let [needId, rows] of Object.entries(popNeeds)) { let totalSpendName = glpkNamer.getName(needId, "spend"); let totalSpendConstraint = subjectTo.needGoodsSpend[needId] ??= getOrCreateBalancingConstraintNamed(totalSpendName, [totalSpendName, "goods", "def"]); for (let row of rows) { let { good, unitCost, spendPctRange } = row; let goodSpendName = glpkNamer.getName(needId, good, "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, ub: 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 } }; } } } // subjectTo.goodsConsumed: Total goods purchased given spend for (let [needId, rows] of Object.entries(popNeeds)) { for (let row of rows) { let { good, unitCost, spendPctRange } = row; let goodConsumedName = glpkNamer.getName(good, "consumed"); let constraint = subjectTo.goodsConsumed[good]; if (!constraint) { constraint = subjectTo.goodsConsumed[good] = getOrCreateBalancingConstraint(goodConsumedName); constraint.vars[0].coef = -unitCost; } setConstraintVar(constraint, [needId, good, "spend"], 1); } } // Set net good production lower bounds based on problemTarget for (let [goodId, target] of Object.entries(problemTarget)) { let constraint = subjectTo.goodsTargets[goodId] = getOrCreateBalancingConstraintNamed(goodId, `${goodId}|target`); setConstraintVar(constraint, "constant", target); } // Set urbanization production bounds based on building count subjectTo.goods["urbanization"].bnds = { type: glpk.GLP_DB, lb: 1 - common.defines.NEconomy.URBANIZATION_PER_BUILDING, ub: 0 }; // return { subjectTo, bounds }; // 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 = _.sortBy(subjectToArray, e => Object.keys(goods).indexOf(e.name)); return { subjectTo, subjectToArray, bounds }; /* // return subjectTo; return _.sortBy(subjectTo, "name"); } */5b:T1938,ProductionMethod = { function findGood(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) return; if (!modifierName.endsWith("add")) throw `Found unexpected modifier ${modifierName}`; return good; } 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 mergeItems(first, second) { let result = {}; first ??= {}; second ??= {}; let itemIds = Object.keys(Object.assign({}, first, second)); itemIds.forEach(id => result[id] = (first[id] ?? 0) + (second[id] ?? 0)); return result; } function scaleItems(list, scalar) { let result = {}; Object.keys(list).forEach(id => result[id] = list[id] * scalar); return result; } function getUnlockingPms(pm) { let unlockingPms = common.production_methods[pm].unlocking_production_methods ?? []; if (unlockingPms.length == 0) return []; return [...unlockingPms, ...unlockingPms.flatMap(pm => getUnlockingPms(pm))]; } function getUnlockingLaws(pm) { return common.production_methods[pm].unlocking_laws ?? []; } class ProductionMethod { constructor(pmOrString) { this.inputs = {}; this.outputs = {}; this.employment = {}; 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)); // Inputs for (let [key, amount] of getModifiers("building_input_")) { let good = findGood(key); if (!good) continue; this.inputs[good._id] = (this.inputs[good._id] ?? 0) + amount; } // Outputs for (let [key, amount] of getModifiers("building_output_")) { let good = findGood(key); if (!good) continue; this.outputs[good._id] = (this.outputs[good._id] ?? 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 for (let [key, amount] of getModifiers("state_infrastructure_")) { this.outputs["infrastructure"] = (this.outputs["infrastructure"] ?? 0) + amount; } for (let [key, amount] of getModifiers("country_bureaucracy_")) { this.outputs["bureaucracy"] = (this.outputs["bureaucracy"] ?? 0) + amount; } for (let [key, amount] of getModifiers("state_tax_capacity_")) { this.outputs["tax_capacity"] = (this.outputs["tax_capacity"] ?? 0) + amount; } // this.inputs["tax_capacity"] = this.employmentCount / common.defines.NPops.INDIVIDUALS_TAXED_PER_TAX_CAPACITY; // this.inputs["bureaucracy"] = this.employmentCount * common.defines.NPolitics.STATE_BUREAUCRACY_POP_BASE_COST / common.defines.NPolitics.STATE_BUREAUCRACY_POP_MULTIPLE; } 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 = mergeItems(this.inputs, otherPm.inputs); result.outputs = mergeItems(this.outputs, otherPm.outputs); result.employment = mergeItems(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) { let result = new ProductionMethod(); ["inputs", "outputs", "employment"].forEach(field => result[field] = scaleItems(this[field], scalar)); result.id = (scalar == 1) ? this.id : `${this.id} x${scalar}`; result.era = this.era; return result; } forSingleOutput(goodId, defaultOutputPct = 0) { let result = new ProductionMethod(); result.id = `[${this.id}].forSingleOutput(${goodId})`; result.era = this.era; 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; } } return ProductionMethod; }5c:T23ed,pcBlob = { function addRange(obj, key, newRange) { if (!newRange) return; obj[key] ??= [0, 0]; obj[key] = obj[key].map((qty, i) => qty + newRange[i]); } // Constants let workersPerBuyPackage = common.defines.NPops.POP_SIZE_PACKAGE; let workersPerBureaucracy = common.defines.NPolitics.STATE_BUREAUCRACY_POP_MULTIPLE / common.defines.NPolitics.STATE_BUREAUCRACY_POP_BASE_COST; let individualsPerTaxCapacity = common.defines.NPops.INDIVIDUALS_TAXED_PER_TAX_CAPACITY; let individualsPerInfrastructure = common.defines.NPops.INDIVIDUALS_PER_POP_INFRASTRUCTURE; let dependentConsumptionRatio = common.defines.NPops.DEPENDENT_CONSUMPTION_RATIO; // popConsumptionRates[popType] = { wealthLevel, consumptionRate, hackNeeds[] } let popConsumptionRates = {}; for (let [popType, popDef] of Object.entries(common.pop_types)) { let popTypeInfo = popConsumptionRates[popType] = {}; popTypeInfo.wealthLevel = common.pop_types[popType].start_quality_of_life; let workingAdultRatio = popDef.working_adult_ratio ?? common.defines.NPops.WORKING_ADULT_RATIO_BASE; let dependentsPerBuyPackage = workersPerBuyPackage * workingAdultRatio; let individualsPerBuyPackage = popTypeInfo.individualsPerBuyPackage = workersPerBuyPackage + dependentsPerBuyPackage; let consumptionMult = popDef.consumption_mult ?? 1; popTypeInfo.consumptionRate = correctPrecision(consumptionMult * (1 + (workingAdultRatio * dependentConsumptionRatio))); popTypeInfo.wageRate = 1 + (workingAdultRatio * popDef.dependent_wage); let hackNeedsAbsolute = popTypeInfo.hackNeedsAbsolute = { infrastructure: correctPrecision(-individualsPerBuyPackage / individualsPerInfrastructure), tax_capacity: correctPrecision(individualsPerBuyPackage / individualsPerTaxCapacity), bureaucracy: correctPrecision(workersPerBuyPackage / workersPerBureaucracy), }; } // create hackNeeds, the relative value of a pop's hackNeedsAbsolute as compared to peasants'. let peasantHackNeedsAbsolute = popConsumptionRates.peasants.hackNeedsAbsolute; let hackGoods = Object.keys(peasantHackNeedsAbsolute); for (let pcr of Object.values(popConsumptionRates)) { let hackNeeds = pcr.hackNeeds = {}; hackGoods.forEach(g => hackNeeds[g] = correctPrecision(pcr.hackNeedsAbsolute[g] - peasantHackNeedsAbsolute[g])); } // cache popNeeds per unique set of availableGoods let popNeedsCache = new Map(); function getOrCreatePopNeeds(availableGoods) { let cacheKey = _.sortBy(_.uniq(availableGoods)).join("|"); if (!popNeedsCache.has(cacheKey)) { let needs = getPopNeeds(availableGoods); Object.freeze(needs); popNeedsCache.set(cacheKey, needs); } return popNeedsCache.get(cacheKey); } // cache buyPackage per wealth level and unique set of availableGoods let buyPackageCache = new Map(); function getOrCreateBuyPackageForWealthLevel(wealthLevel, availableGoods) { if (typeof(wealthLevel) == "number") wealthLevel = `wealth_${wealthLevel}`; let cacheKey = [wealthLevel, ..._.sortBy(_.uniq(availableGoods))].join("|"); if (!buyPackageCache.has(cacheKey)) { let bpDef = common.buy_packages[wealthLevel].goods; let popNeeds = getOrCreatePopNeeds(availableGoods); let buyPackage = {}; for (let [needType, dollars] of Object.entries(bpDef)) { if (Number.isNaN(popNeeds[needType])) { buyPackage[needType] = NaN; continue; } let needSpend = bpDef[needType]; let bpRow = buyPackage[needType] = { needSpend, goods: {} }; for (let pnRow of popNeeds[needType]) { bpRow.goods[pnRow.good] = { unitCost: pnRow.unitCost, spendRangePct: correctPrecision(pnRow.spendPctRange) }; } } Object.freeze(buyPackage); buyPackageCache.set(cacheKey, buyPackage); } return buyPackageCache.get(cacheKey); } // cache popGoods per pop type and unique set of availableGoods let popGoodsCache = new Map(); function getOrCreatePopGoods(popType, availableGoods) { let cacheKey = [popType, ..._.sortBy(_.uniq(availableGoods))].join("|"); if (!popGoodsCache.has(cacheKey)) { let pcr = popConsumptionRates[popType]; let buyPackage = getOrCreateBuyPackageForWealthLevel(pcr.wealthLevel, availableGoods); let popGoods = _.cloneDeep(buyPackage); popGoods.totalSpend = 0; popGoods.wealthLevel = pcr.wealthLevel; for (let needId of Object.keys(buyPackage)) { let need = popGoods[needId]; if (Number.isNaN(need)) { popGoods[needId] = NaN; continue; }; need.needSpend = correctPrecision(need.needSpend * pcr.consumptionRate); popGoods.totalSpend += need.needSpend; } popGoods.totalSpend = correctPrecision(popGoods.totalSpend); popGoods.hackNeeds = _.cloneDeep(pcr.hackNeeds); Object.freeze(popGoods); popGoodsCache.set(cacheKey, popGoods); } return popGoodsCache.get(cacheKey); } // cache default consumption rates let consumptionRateCache = new Map(); function getDefaultConsumptionRates(availableGoods) { let cacheKey = [..._.sortBy(_.uniq(availableGoods))].join("|"); if (!consumptionRateCache.has(cacheKey)) { let popNeeds = getOrCreatePopNeeds(availableGoods); let consumptionRate = {}; for (let [needId, need] of Object.entries(popNeeds)) { consumptionRate[needId] = Object.fromEntries(need.map(n => [ n.good, n.weight ])); } Object.freeze(consumptionRate); consumptionRateCache.set(cacheKey, consumptionRate); } return consumptionRateCache.get(cacheKey); } // let defaultImportableGoods = Object.entries(goods).filter(e => e[1].tradeable).map(e => e[0]); class PopConsumption { static { PopConsumption.defaultSize = workersPerBuyPackage; } constructor(popType, availableGoods = Object.keys(goods)) { if (popType === undefined) return; this.popType = popType; for (let [needId, need] of Object.entries(getOrCreatePopGoods(popType, availableGoods))) { this[needId] = _.cloneDeep(need); } this.defaultConsumptionRates = getDefaultConsumptionRates(availableGoods); } get isSatisfyable() { return this.needIds.map(n => this[n]).every(n => !Number.isNaN(n)); } get needIds() { return _.intersection(Object.keys(this), Object.keys(common.pop_needs)); } get eligibleGoods() { let needs = this.needIds.map(n => this[n]); let goods = needs.flatMap(n => Object.keys(n.goods)); return _.uniq(goods); } get popCount() { let initialTotalSpend = getOrCreatePopGoods(this.popType, availableGoods).totalSpend; return correctPrecision(this.totalSpend / initialTotalSpend); } combine(otherPc) { let result = new PopConsumption(); for (let obj of [this, otherPc]) { for (let needId of obj.needIds) { let need = obj[needId]; let resultNeed = result[needId] ??= { needSpend: 0, goods: {} }; resultNeed.needSpend += need.needSpend; for (let [goodId, goodInfo] of Object.entries(need.goods)) { let resultNeedGood = resultNeed.goods[goodId] ??= { unitCost: goodInfo.unitCost }; let copy = _.cloneDeep(resultNeedGood); addRange(resultNeedGood, "spendRange", goodInfo.spendRange); } } result.hackNeeds ??= {}; for (let [goodId, range] of Object.entries(obj.hackNeeds)) { let before = _.cloneDeep(result.hackNeeds); addRange(result.hackNeeds, goodId, range); console.log({ goodId, range, before, after: _.cloneDeep(result.hackNeeds) }); } } return result; } scale(scalar = 1) { let result = new PopConsumption(); Object.assign(result, _.cloneDeep(this)); result.totalSpend = correctPrecision(result.totalSpend * scalar); for (let needId of result.needIds) { let need = result[needId]; need.needSpend *= scalar; } for (let goodId of Object.keys(result.hackNeeds)) { result.hackNeeds[goodId] = correctPrecision(result.hackNeeds[goodId] * scalar); } return result; } getConsumptionVolumes(consumptionRates) { let goodsSpend = {}; for (let needId of this.needIds) { for (let goodId of Object.keys(this[needId].goods)) { goodsSpend[goodId] ??= 0; goodsSpend[goodId] += this[needId].needSpend * consumptionRates[needId][goodId]; } } let goodsQty = Object.entries(goodsSpend).map(e => [e[0], e[1] / goods[e[0]].cost]); for (let [goodId, qty] of Object.entries(this.hackNeeds)) { goodsQty.push([goodId, qty]); } goodsQty.forEach(e => e[1] = correctPrecision(e[1])); goodsQty = goodsQty.filter(e => e[1]); goodsQty = _.sortBy(goodsQty, e => Object.keys(goods).indexOf(e[0])); return Object.fromEntries(goodsQty); } } return { popConsumptionRates, popNeedsCache, buyPackageCache, popGoodsCache, consumptionRateCache, PopConsumption } }5d:T854,function getPopNeeds(availableGoods) { let popNeeds = {} 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) { popNeeds[name] = NaN; continue; } let popGoods = []; let sumOfWeights = entryDefs.reduce((sum, e) => sum + e.weight, 0); for (let entryDef of entryDefs) { let row = { good: entryDef.goods, unitCost: goods[entryDef.goods].cost, 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) ] }; correctPrecision(row.spendPctRange); popGoods.push(row) } popGoods = _.sortBy(popGoods, [r => 1 - r.weight, "unitCost", "good"]); popNeeds[name] = popGoods; } for (let [needId, popGoods] of Object.entries(popNeeds)) { if (Number.isNaN(popGoods)) continue; let ranges = popGoods.map(g => g.spendPctRange).map(r => [ Math.max(0, r[0]), Math.min(1, r[1]) ]); let trueRanges = []; let allMaxes = ranges.map(r => r[1]); for (let i = 0; i < ranges.length; i++) { let range = ranges[i]; let otherMaxes = allMaxes.filter((m,j) => i != j); let sumOfOtherMaxes = otherMaxes.reduce((sum, m) => sum + m, 0); let min = Math.max(range[0], correctPrecision(1 - sumOfOtherMaxes)); let max = range[1]; popNeeds[needId][i].spendPctRange = [min, max]; } } 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; } }); return sortObjectByKeys(popNeeds, [ n => bpNeedsOrder[n].first, n => bpNeedsOrder[n].last ]); }5e:T10a4,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 = []; for (let [buildingId, building] of Object.entries(buildings)) { 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_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); }; } 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()); for (let pms of pmSelections) { pms.era = getEraName(pmsEras.get(pms)); delete pms.buildingAndPmEraNum; } return _.sortBy(pmSelections, [ "building", "era", "id" ]); }5f:T55e,goods = { 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 = undefined; goods[goodId].category = "hack"; } return goods[goodId]; } for (let pms of productionMethodSelections) { for (let goodId of Object.keys(pms.combinedPm.outputs)) { let good = getGood(goodId); good.productionMethodSelections.push(pms); } } for (let good of Object.values(goods)) { let allEraNums = _.uniq(good.productionMethodSelections.map(pms => getEraNum(pms.era))); good.era = getEraName(Math.min(...allEraNums)); } let entries = Object.entries(goods); entries = _.sortBy(entries, [e => hackGoods.includes(e[0]), 0]); return Object.fromEntries(entries); }60:T5f8,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; } return sortObjectByKeys(buildings); }61:T659,laws = { let bpmgls = []; for (let building of Object.values(common.buildings)) { for (let pmg of building.production_method_groups.map(pmg => common.production_method_groups[pmg])) { let pms = (pmg.production_methods ?? []); for (let law of pms.flatMap(pm => common.production_methods[pm].unlocking_laws ?? [])) { bpmgls.push({ law, building: building._id, pms }); } } } let lawImpacts = Object.values(_.groupBy(bpmgls, "law")) .map(bpmg => [ bpmg[0].law, { buildings: _.uniq(bpmg.map(e => e.building)).length, pms: _.uniq(bpmg.flatMap(e => e.pms)).length } ]); lawImpacts = Object.fromEntries(lawImpacts); 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: getRelevantModifiers(lawDef), unlocks: lawImpacts[lawId] }; } return sortObjectBy(laws, l => getSortNum(l)); }62: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; }63: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; */ }64: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; }65:T948,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 = /(?