poker-flopsolve 0.2.0 → 0.3.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +21 -9
- package/dist/browser.js +421 -138
- package/dist/browser.js.map +1 -1
- package/dist/engine-worker.d.ts +2 -0
- package/dist/engine-worker.js +57 -0
- package/dist/engine-worker.js.map +1 -0
- package/dist/index.d.ts +12 -2
- package/dist/index.js +433 -139
- package/dist/index.js.map +1 -1
- package/dist/worker.js.map +1 -1
- package/package.json +1 -1
package/dist/browser.js
CHANGED
|
@@ -2078,135 +2078,11 @@ function makeSolver(ctx) {
|
|
|
2078
2078
|
};
|
|
2079
2079
|
}
|
|
2080
2080
|
|
|
2081
|
-
// src/
|
|
2082
|
-
var
|
|
2083
|
-
|
|
2084
|
-
|
|
2085
|
-
|
|
2086
|
-
const match = new Int32Array(to.nodeCount).fill(-1);
|
|
2087
|
-
const walk2 = (a, b) => {
|
|
2088
|
-
if (to.kind[a] !== from.kind[b] || to.round[a] !== from.round[b]) return;
|
|
2089
|
-
if (to.kind[a] === NodeKind.Chance) {
|
|
2090
|
-
walk2(to.edgeChild[to.firstEdge[a]], from.edgeChild[from.firstEdge[b]]);
|
|
2091
|
-
return;
|
|
2092
|
-
}
|
|
2093
|
-
if (to.kind[a] !== NodeKind.Decision || to.player[a] !== from.player[b]) return;
|
|
2094
|
-
match[a] = b;
|
|
2095
|
-
for (let e = 0; e < to.numEdges[a]; e++) {
|
|
2096
|
-
const edge = to.firstEdge[a] + e;
|
|
2097
|
-
const other = matchEdge(to, edge, a, from, b);
|
|
2098
|
-
if (other >= 0) walk2(to.edgeChild[edge], from.edgeChild[other]);
|
|
2099
|
-
}
|
|
2100
|
-
};
|
|
2101
|
-
walk2(0, 0);
|
|
2102
|
-
return match;
|
|
2103
|
-
}
|
|
2104
|
-
function matchEdge(to, edge, node, from, other) {
|
|
2105
|
-
const kind = to.edgeAction[edge];
|
|
2106
|
-
const sized = kind === ActionKind.Bet || kind === ActionKind.Raise;
|
|
2107
|
-
const size = to.edgeTarget[edge] / to.pot[node];
|
|
2108
|
-
let best = -1;
|
|
2109
|
-
let bestGap = Infinity;
|
|
2110
|
-
for (let e = 0; e < from.numEdges[other]; e++) {
|
|
2111
|
-
const candidate = from.firstEdge[other] + e;
|
|
2112
|
-
if (from.edgeAction[candidate] !== kind) continue;
|
|
2113
|
-
if (!sized) return candidate;
|
|
2114
|
-
const gap = Math.abs(Math.log(from.edgeTarget[candidate] / from.pot[other] / size));
|
|
2115
|
-
if (gap < bestGap) {
|
|
2116
|
-
bestGap = gap;
|
|
2117
|
-
best = candidate;
|
|
2118
|
-
}
|
|
2119
|
-
}
|
|
2120
|
-
return bestGap <= Math.log(SIZE_TOLERANCE) ? best : -1;
|
|
2121
|
-
}
|
|
2122
|
-
function readBlock(store, scale, block, base, length, out) {
|
|
2123
|
-
const factor = scale ? scale[block] : 1;
|
|
2124
|
-
for (let i = 0; i < length; i++) out[i] = store[base + i] * factor;
|
|
2125
|
-
}
|
|
2126
|
-
function writeBlock(store, scale, steps, block, base, length, values) {
|
|
2127
|
-
if (!scale) {
|
|
2128
|
-
for (let i = 0; i < length; i++) store[base + i] = values[i];
|
|
2129
|
-
return;
|
|
2130
|
-
}
|
|
2131
|
-
let largest = 0;
|
|
2132
|
-
for (let i = 0; i < length; i++) {
|
|
2133
|
-
const magnitude = Math.abs(values[i]);
|
|
2134
|
-
if (magnitude > largest) largest = magnitude;
|
|
2135
|
-
}
|
|
2136
|
-
const step = largest > 0 ? steps / largest : 0;
|
|
2137
|
-
for (let i = 0; i < length; i++) store[base + i] = Math.round(values[i] * step);
|
|
2138
|
-
scale[block] = largest / steps;
|
|
2139
|
-
}
|
|
2140
|
-
function realCards(runouts, round, board) {
|
|
2141
|
-
const width = runouts.width[round];
|
|
2142
|
-
return Array.from(runouts.cards[round].subarray(board * width, (board + 1) * width));
|
|
2143
|
-
}
|
|
2144
|
-
function warmStart(to, from, averages) {
|
|
2145
|
-
const a = to.runouts.initial;
|
|
2146
|
-
const b = from.runouts.initial;
|
|
2147
|
-
if (a.length !== b.length || a.some((card, i) => card !== b[i])) {
|
|
2148
|
-
throw new Error("A warm start must come from a solve of the same board");
|
|
2149
|
-
}
|
|
2150
|
-
const match = matchNodes(to.tree, from.tree);
|
|
2151
|
-
const { tree } = to;
|
|
2152
|
-
const width = to.layout.maxActions * COMBOS;
|
|
2153
|
-
const oldRegret = new Float64Array(width);
|
|
2154
|
-
const oldSum = new Float64Array(width);
|
|
2155
|
-
const newRegret = new Float64Array(width);
|
|
2156
|
-
const newSum = new Float64Array(width);
|
|
2157
|
-
const hasRegret = to.regret.length > 0 && from.regret.length > 0;
|
|
2158
|
-
const position = new Int32Array(COMBOS).fill(-1);
|
|
2159
|
-
let matched = 0;
|
|
2160
|
-
for (const node of tree.decisionNodes) {
|
|
2161
|
-
const old = match[node];
|
|
2162
|
-
if (old < 0) continue;
|
|
2163
|
-
matched++;
|
|
2164
|
-
const round = tree.round[node];
|
|
2165
|
-
const owner = tree.player[node];
|
|
2166
|
-
const actions = tree.numEdges[node];
|
|
2167
|
-
const oldActions = from.tree.numEdges[old];
|
|
2168
|
-
const actionOf = new Int32Array(actions).fill(-1);
|
|
2169
|
-
for (let e = 0; e < actions; e++) {
|
|
2170
|
-
const other = matchEdge(tree, tree.firstEdge[node] + e, node, from.tree, old);
|
|
2171
|
-
if (other >= 0) actionOf[e] = other - from.tree.firstEdge[old];
|
|
2172
|
-
}
|
|
2173
|
-
for (let board = 0; board < to.runouts.counts[round]; board++) {
|
|
2174
|
-
const resolved = resolveBoard(from.runouts, realCards(to.runouts, round, board));
|
|
2175
|
-
const oldSlot = (from.active.roundBase[round] + resolved.board) * 2 + owner;
|
|
2176
|
-
const oldFrom = from.active.start[oldSlot];
|
|
2177
|
-
const oldCount = from.active.count[oldSlot];
|
|
2178
|
-
const oldBlock = from.layout.blockOffset[old] + resolved.board;
|
|
2179
|
-
const oldBase = from.layout.offset[old] + oldActions * from.layout.rowStart[oldSlot];
|
|
2180
|
-
const oldLength = oldActions * oldCount;
|
|
2181
|
-
if (hasRegret) readBlock(from.regret, from.regretScale, oldBlock, oldBase, oldLength, oldRegret);
|
|
2182
|
-
readBlock(from.strategySum, from.sumScale, oldBlock, oldBase, oldLength, oldSum);
|
|
2183
|
-
for (let j = 0; j < oldCount; j++) position[from.active.list[oldFrom + j]] = j;
|
|
2184
|
-
const newSlot = (to.active.roundBase[round] + board) * 2 + owner;
|
|
2185
|
-
const newFrom = to.active.start[newSlot];
|
|
2186
|
-
const count = to.active.count[newSlot];
|
|
2187
|
-
const length = actions * count;
|
|
2188
|
-
newRegret.fill(0, 0, length);
|
|
2189
|
-
newSum.fill(0, 0, length);
|
|
2190
|
-
for (let i = 0; i < count; i++) {
|
|
2191
|
-
const j = position[resolved.combos[to.active.list[newFrom + i]]];
|
|
2192
|
-
if (j < 0) continue;
|
|
2193
|
-
for (let e = 0; e < actions; e++) {
|
|
2194
|
-
const action = actionOf[e];
|
|
2195
|
-
if (action < 0) continue;
|
|
2196
|
-
newRegret[e * count + i] = oldRegret[action * oldCount + j];
|
|
2197
|
-
newSum[e * count + i] = oldSum[action * oldCount + j];
|
|
2198
|
-
}
|
|
2199
|
-
}
|
|
2200
|
-
for (let j = 0; j < oldCount; j++) position[from.active.list[oldFrom + j]] = -1;
|
|
2201
|
-
const block = to.layout.blockOffset[node] + board;
|
|
2202
|
-
const base = to.layout.offset[node] + actions * to.layout.rowStart[newSlot];
|
|
2203
|
-
if (hasRegret) writeBlock(to.regret, to.regretScale, REGRET_STEPS2, block, base, length, newRegret);
|
|
2204
|
-
if (averages) writeBlock(to.strategySum, to.sumScale, SUM_STEPS2, block, base, length, newSum);
|
|
2205
|
-
tieBlock(to, node, board);
|
|
2206
|
-
}
|
|
2207
|
-
}
|
|
2208
|
-
return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
|
|
2209
|
-
}
|
|
2081
|
+
// src/wasm/engine.ts
|
|
2082
|
+
var ENGINE_WASM = "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";
|
|
2083
|
+
|
|
2084
|
+
// src/wasm/engine-shared.ts
|
|
2085
|
+
var ENGINE_SHARED_WASM = "AGFzbQEAAAABTglgAX8AYAZ/f39/f38Bf2AFf39/f38AYAd/f39/f3x/AGADf39/AGACf38AYAR/f39/AGAKf39/f399fX19fwF/YAl/f39/fX19fX8BfwISAQNlbnYGbWVtb3J5AgMAgIAEAwsKAQIDBAUABgcIAAaOAjJ/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC38BQQALfwFBAAt8AUQAAAAAAADwPwt/AUF/C38BQQALfwFBAAt/AUEAC38BQQELfwFBAAt/AUEAC38BQQALfwFBAAt/AUEAC30BQwAAgD8LfQFDAAAAAAt9AUMAAIA/C30BQwAAgD8LfwFBAAt/AUEBCwdXCAhzZXRTaGFyZAADC3NldEV4Y2hhbmdlAAYIc2V0UGhhc2UABARpbml0AAkNc2V0TWF4QWN0aW9ucwAFA3J1bgAICXJ1bkNoYW5jZQAHBm1lbW9yeQIACqshCuIYBBV/An0FewN8Ix0gBSMebGohDSACIwkjASABai0AACIHQQJ0aigCAGpBAXQiCCAAaiIPQQJ0IgkjCmooAgAhCiMLIAlqKAIAIQtBASAAayIQIAhqIghBAnQiESMKaigCACESIwsgEWooAgAhESMAIAFqLQAAIhNBAkYEQCMUIAlqKAIAIQIjBiABQQJ0aigCALciIpogIiAAQQFGGyMaIAdBA3RqKwMAoiMhoyEkQQAhAANAIAAgEUgEQCAjIAQgAEECdGoqAgC7IiKgISMjICAAIBJqIgEjDGotAABBA3RqIgMgAysDACAioDkDACMgIw0gAWotAABBA3RqIgEgASsDACAioDkDACAAQQFqIQAMAQsLQQAhAANAIAAgC0gEQCANIABBAnRqICQgIyMgIAAgCmoiASMMai0AAEEDdGorAwAjICMNIAFqLQAAQQN0aisDAKAjFSAAIAJqQQJ0aigCACIBQQBOBHwgBCABQQJ0aioCALsFRAAAAAAAAAAAC6GhorY4AgAgAEEBaiEADAELCyMgQQBBoAP8CwAgDQ8LIBNBAksEQCAEIBIgESAKIAsjBiABQQJ0aigCALcjGiAHQQN0aisDAKIjIaMgDRACIA0PCyATQQFGBEAgDUEAIAtBAnQiBvwLACAHQQFqIgcjIkYjJUEAR3EEQCMnIAFBAnRqKAIAIghBAE4EQCMlQQFGBEAjKCMqIAhBAXRsaiIAIAMgBvwKAAAgACMqaiAEIBFBAnT8CgAABSANIykgCCMqbGogC0ECdPwKAAALIA0PCwsjBSMDIAFBAnRqKAIAQQJ0aigCACEIIxkgB0ECdCIBIxhqKAIAQQJ0aiEJIxIjESABaigCAEECdGohCiMdIAUjHmxqIgYjHyAAQQFqbGohCyMJIAFqKAIAIQ8jFyMWIAFqKAIAQQJ0aiIMIAJBAnRqKAIAIQEgDCACQQFqQQJ0aigCACEMIAcjIkYEQCMkIAwjJCAMSBshDCMjIAEjIyABShshAQsgBiMfIBBBAWpsaiEHA0AgASAMSARAIwsgASAPakEBdCICIABqQQJ0aigCACERIwsgAiAQakECdGooAgAhEiAJIAFBAWpBAnRqKAIAIRNBACEGIAkgAUECdGooAgAiFCECA0AgAiATSARAIxMgCiACQQF0Ig4gAGpBAnRqKAIAQQF0aiEVIAIgFEYEQCMTIAogDiAQakECdGooAgBBAXRqIQZBACEOA0AgDiARSARAIAsgDkECdGogAyAVIA5BAXRqLwEAQQJ0aioCADgCACAOQQFqIQ4MAQsLQQAhDgNAIA4gEkgEQCAHIA5BAnRqIAQgBiAOQQF0ai8BAEECdGoqAgA4AgAgDkEBaiEODAELCyAAIAggASALIAcgBUEBahAAIQYLQQAhDgNAIA4gEUgEQCANIBUgDkEBdGovAQBBAnRqIhYgFioCACAGIA5BAnRqKgIAkjgCACAOQQFqIQ4MAQsLIAJBAWohAgwBCwsgAUEBaiEBDAELCyANDwsgAUECdCIHIwNqKAIAIQojByAHaigCACMEIAFqLQAAIgkjCCAPIAgjAiABai0AACIQIABGIggbIhJBAnRqKAIAbGpBAnQiASMbaiETIxwgAWohFCMdIAUjHmxqIx9BA2xqIRUgCyARIAgbIhFBAnQiASEWIysEQCAVIAEgCWxqIgdBACAB/AsAA0AgCSAOSgRAIAEgDmwiBiAUaiEXIAYgFWohBkEAIQ8DQCAPIBFIBEAgD0ECdCIYIBdqKgIAIRsgBiAYaiAbOAIAIAcgGGoiGCAYKgIAIBuSOAIAIA9BAWohDwwBCwsgDkEBaiEODAELC0EAIQ4DQCAOIBFIBEAgDkECdCIGIAdqKgIAQwAAAABeRQRAQwAAAAAhG0EAIQ8DQCAJIA9KBEAgASAPbCIXIBNqIAZqKgIAIhxDAAAAACAcQwAAAABeGyEcIBUgF2ogBmogHDgCACAbIBySIRsgD0EBaiEPDAELCyAGIAdqIBs4AgALIA5BAWohDgwBCwsFIBFBfHEhASAVIBFBAnQiDiAJbGoiB0EAIA78CwADQCAGIAlIBEAgBiAObCIPIBNqIRcgDyAVaiEYQQAhDwNAIAEgD0oEQCAPQQJ0IhkgF2r9AAQA/QwAAAAAAAAAAAAAAAAAAAAA/ekBIR0gGCAZaiAd/QsEACAHIBlqIhkgGf0ABAAgHf3kAf0LBAAgD0EEaiEPDAELCwNAIA8gEUgEQCAPQQJ0IhkgF2oqAgAiG0MAAAAAIBtDAAAAAF4bIRsgGCAZaiAbOAIAIAcgGWoiGSAZKgIAIBuSOAIAIA9BAWohDwwBCwsgBkEBaiEGDAELCwtBACEPIBFBAnQhBkMAAIA/IAmylf0TIR0gEUF8cSEOA0AgCSAPSgRAIBUgBiAPbGohF0EAIQEDQCABIA5IBEAgAUECdCIYIAdq/QAEACEeIBcgGGoiGCAY/QAEACAe/ecBIB0gHv0MAAAAAAAAAAAAAAAAAAAAAP1E/VL9CwQAIAFBBGohAQwBCwsDQCABIBFIBEAgAUECdCIYIAdqKgIAIRsgFyAYaiIYIBtDAAAAAF4EfSAYKgIAIBuVBUMAAIA/IAmylQs4AgAgAUEBaiEBDAELCyAPQQFqIQ8MAQsLIytBAUYgCHEEQANAIAkgDEoEQCAAIwUgCiAMakECdGooAgAgAiADIAQgBUEBahAAIQYgDARAQQAhAQNAIAEgC0gEQCABQQJ0IgcgBmoqAgAiGyAHIA1qIgcqAgBeBEAgByAbOAIACyABQQFqIQEMAQsLBSANIAYgC0ECdPwKAAALIAxBAWohDAwBCwsgDQ8LIA1BACALQQJ0/AsAIx0gBSMebGoiASMfIBBBAWpsaiEGIAEjH0EDbGojMSMfbGohASADIAQgCBshByARQXxxIQwgC0F8cSEQQQAhDgNAIAkgDkoEQCAVIA4gFmxqIRdBACEPA0AgDCAPSgRAIA9BAnQiGCAGaiAHIBhq/QAEACAXIBhq/QAEAP3mAf0LBAAgD0EEaiEPDAELCwNAIA8gEUgEQCAPQQJ0IhggBmogByAYaioCACAXIBhqKgIAlDgCACAPQQFqIQ8MAQsLIAgEfyAAIwUgCiAOakECdGooAgAgAiAGIAQgBUEBahAABSAAIwUgCiAOakECdGooAgAgAiADIAYgBUEBahAACyEYIAgEQCABIA4gFmxqIBggFvwKAABBACEPA0AgDyAQSARAIA9BAnQiGSANaiIaIBr9AAQAIBcgGWr9AAQAIBggGWr9AAQA/eYB/eQB/QsEACAPQQRqIQ8MAQsLA0AgCyAPSgRAIA9BAnQiGSANaiIaIBoqAgAgFyAZaioCACAYIBlqKgIAlJI4AgAgD0EBaiEPDAELCwVBACEPA0AgDyAQSARAIA9BAnQiFyANaiIZIBn9AAQAIBcgGGr9AAQA/eQB/QsEACAPQQRqIQ8MAQsLA0AgCyAPSgRAIA9BAnQiFyANaiIZIBkqAgAgFyAYaioCAJI4AgAgD0EBaiEPDAELCwsgDkEBaiEODAELCyMmQQAjK0UgCHEbBEBBACEFIBFBAnQhACMs/RMhICMt/RMhHyMu/RMhHiMv/RMhHSARQXxxIQQDQCAFIAlIBEAgACAFbCEGQQAhAgNAIAIgBEgEQCAGIBNqIgcgAkECdCIIav0ABAAiISAgIB8gIf0MAAAAAAAAAAAAAAAAAAAAAP1E/VL95gEgASAGaiAIav0ABAAgCCANav0ABAD95QH95AEhISAHIAhqICH9DAAAAAAAAAAAAAAAAAAAAAD96QEgISMwG/0LBAAgBiAUaiAIaiIHIAf9AAQAIB795gEgHSADIAhq/QAEACAGIBVqIAhq/QAEAP3mAf3mAf3kAf0LBAAgAkEEaiECDAELCwNAIAIgEUgEQCACQQJ0IgcgBiATamoqAgAiGyMsIy0gG0MAAAAAXhuUIAEgBmogB2oqAgCSIAcgDWoqAgCTIhtDAAAAAF1BACMwGwRAQwAAAAAhGwsgBiATaiAHaiAbOAIAIAYgFGogB2oiCCAIKgIAIy6UIy8gAyAHaioCAJQgBiAVaiAHaioCAJSSOAIAIAJBAWohAgwBCwsgBUEBaiEFDAELCyMPIBJBAnRqKAIAIgAjDyASQQFqQQJ0aigCACIBSARAIBMgCSARIAAgARABIBQgCSARIAAgARABCwsgDQvHAQIFfwF9IAJBAnQhCQNAIAEgB0oEQCAAIAcgCWxqIQggAyECA0AgAiAESARAIxAgAkECdGooAgAhBkMAAAAAIQpBASEFA0AgBSAGTARAIAogCCMQIAIgBWpBAnRqKAIAQQJ0aioCAJIhCiAFQQFqIQUMAQsLIAogBrKVIQpBASEFA0AgBSAGTARAIAgjECACIAVqQQJ0aigCAEECdGogCjgCACAFQQFqIQUMAQsLIAIgBkEBamohAgwBCwsgB0EBaiEHDAELCwvxAwIGfwJ8IyBBoANqIQkDQCAEIAhKBEAjDiADIAhqQQJ0aigCACELA0AgAiAHSgR/Iw4gASAHakECdGooAgAgC0gFQQALBEAgDSAAIAdBAnRqKgIAuyIOoCENIyAgASAHaiIKIwxqLQAAQQN0aiIMIAwrAwAgDqA5AwAjICMNIApqLQAAQQN0aiIKIAorAwAgDqA5AwAgB0EBaiEHDAELCyAJIAhBA3RqIA0jICADIAhqIgojDGotAABBA3RqKwMAIyAjDSAKai0AAEEDdGorAwCgoTkDACAIQQFqIQgMAQsLIyBBAEGgA/wLAEQAAAAAAAAAACENIAJBAWshByAEQQFrIQIDQCACQQBOBEAjDiACIANqQQJ0aigCACEEA0AgB0EATgR/Iw4gASAHakECdGooAgAgBEoFQQALBEAgDSAAIAdBAnRqKgIAuyIOoCENIyAgASAHaiIIIwxqLQAAQQN0aiIKIAorAwAgDqA5AwAjICMNIAhqLQAAQQN0aiIIIAgrAwAgDqA5AwAgB0EBayEHDAELCyAGIAJBAnRqIAUgCSACQQN0aisDACANIyAgAiADaiIEIwxqLQAAQQN0aisDACMgIw0gBGotAABBA3RqKwMAoKGhorY4AgAgAkEBayECDAELCyMgQQBBoAP8CwALDgAgACQiIAEkIyACJCQLDQAgACQlIAFBAEckJgsGACAAJDELFQAgACQnIAEkKCACJCkgA0ECdCQqCysAIAAkKyAFJCwgBiQtIAckLiAIJC8gCUEARyQwIAEgAkEAIAMgBEEAEAALKwAgACQrIAQkLCAFJC0gBiQuIAckLyAIQQBHJDAgAUEAQQAgAiADQQAQAAv2AQAgACgCACQAIAAoAgQkASAAKAIIJAIgACgCDCQDIAAoAhAkBCAAKAIUJAUgACgCGCQGIAAoAhwkByAAKAIgJAggACgCJCQJIAAoAigkCiAAKAIsJAsgACgCMCQMIAAoAjQkDSAAKAI4JA4gACgCPCQPIABBQGsoAgAkECAAKAJEJBEgACgCSCQSIAAoAkwkEyAAKAJQJBQgACgCVCQVIAAoAlgkFiAAKAJcJBcgACgCYCQYIAAoAmQkGSAAKAJoJBogACgCbCQbIAAoAnAkHCAAKAJ0JB0gACgCeCQeIAAoAnwkHyAAKAKAASQgIAAoAoQBuCQhCw==";
|
|
2210
2086
|
|
|
2211
2087
|
// src/platform/browser.ts
|
|
2212
2088
|
var PLATFORM = "browser";
|
|
@@ -2218,6 +2094,9 @@ function defaultWorkerCount() {
|
|
|
2218
2094
|
function spawnWorker(_setup, _onError) {
|
|
2219
2095
|
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2220
2096
|
}
|
|
2097
|
+
function spawnEngineWorker(_setup, _onError) {
|
|
2098
|
+
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2099
|
+
}
|
|
2221
2100
|
|
|
2222
2101
|
// src/parallel.ts
|
|
2223
2102
|
var CONTROL = {
|
|
@@ -2231,6 +2110,8 @@ var CONTROL = {
|
|
|
2231
2110
|
size: 8
|
|
2232
2111
|
};
|
|
2233
2112
|
var COMMAND = { work: 0, exit: 1 };
|
|
2113
|
+
var WORKER_START_MS = 3e4;
|
|
2114
|
+
var WORKER_START_ERROR = "Worker threads did not start within 30 s. Run with workers: 1, or check that worker threads can load this package.";
|
|
2234
2115
|
function planShards(tree, runouts, workers) {
|
|
2235
2116
|
if (workers < 2) return null;
|
|
2236
2117
|
let round = -1;
|
|
@@ -2291,10 +2172,12 @@ function startPool(ctx, solver, plan, payload, workers) {
|
|
|
2291
2172
|
});
|
|
2292
2173
|
threads.push(thread);
|
|
2293
2174
|
}
|
|
2175
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2294
2176
|
for (; ; ) {
|
|
2295
2177
|
const ready = Atomics.load(control, CONTROL.ready);
|
|
2296
2178
|
if (ready >= spawned || failure) break;
|
|
2297
|
-
|
|
2179
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2180
|
+
else Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2298
2181
|
}
|
|
2299
2182
|
if (failure) {
|
|
2300
2183
|
for (const thread of threads) thread.terminate();
|
|
@@ -2384,6 +2267,388 @@ function startPool(ctx, solver, plan, payload, workers) {
|
|
|
2384
2267
|
};
|
|
2385
2268
|
}
|
|
2386
2269
|
|
|
2270
|
+
// src/engine.ts
|
|
2271
|
+
var wasm2 = globalThis.WebAssembly;
|
|
2272
|
+
var modules = { plain: void 0, shared: void 0 };
|
|
2273
|
+
function compiledEngine(kind) {
|
|
2274
|
+
if (modules[kind] !== void 0) return modules[kind];
|
|
2275
|
+
modules[kind] = null;
|
|
2276
|
+
try {
|
|
2277
|
+
if (!wasm2) return null;
|
|
2278
|
+
const text = kind === "plain" ? ENGINE_WASM : ENGINE_SHARED_WASM;
|
|
2279
|
+
const bytes = Uint8Array.from(atob(text), (c) => c.charCodeAt(0));
|
|
2280
|
+
if (!wasm2.validate(bytes)) return null;
|
|
2281
|
+
modules[kind] = new wasm2.Module(bytes);
|
|
2282
|
+
} catch {
|
|
2283
|
+
modules[kind] = null;
|
|
2284
|
+
}
|
|
2285
|
+
return modules[kind];
|
|
2286
|
+
}
|
|
2287
|
+
var ENGINE_CONTROL = { generation: 0, done: 1, command: 2, mode: 3, traverser: 4, ready: 5, size: 8 };
|
|
2288
|
+
function createEngine(input, pool) {
|
|
2289
|
+
const shared = pool !== void 0;
|
|
2290
|
+
const compiledModule = compiledEngine(shared ? "shared" : "plain");
|
|
2291
|
+
if (!compiledModule || !wasm2) return null;
|
|
2292
|
+
const { tree, runouts, layout, active, hands } = input;
|
|
2293
|
+
const threads = pool ? pool.threads : 1;
|
|
2294
|
+
const flatten = (parts) => {
|
|
2295
|
+
const bases = new Int32Array(parts.length + 1);
|
|
2296
|
+
for (let i = 0; i < parts.length; i++) bases[i + 1] = bases[i] + parts[i].length;
|
|
2297
|
+
const flat = new Int32Array(bases[parts.length]);
|
|
2298
|
+
parts.forEach((part, i) => flat.set(part, bases[i]));
|
|
2299
|
+
return [bases, flat];
|
|
2300
|
+
};
|
|
2301
|
+
const [upRound, upStart] = flatten(hands.upStart);
|
|
2302
|
+
const [childRound, childStart] = flatten(runouts.childStart);
|
|
2303
|
+
const [orbitRound, orbitStart] = flatten(runouts.orbitStart);
|
|
2304
|
+
const maxCount = Math.max(4, ...active.count);
|
|
2305
|
+
const stride = Math.ceil(maxCount / 4) * 4;
|
|
2306
|
+
const maxActions = Math.max(1, layout.maxActions);
|
|
2307
|
+
const depths = treeDepth2(tree) + 2;
|
|
2308
|
+
const rowBytes = stride * 4;
|
|
2309
|
+
const depthBytes = rowBytes * (3 + 2 * maxActions);
|
|
2310
|
+
const pieces = [];
|
|
2311
|
+
const add = (data, bytes2 = data ? data.byteLength : 0) => {
|
|
2312
|
+
pieces.push({ data, bytes: Math.ceil(Math.max(bytes2, 4) / 16) * 16 });
|
|
2313
|
+
return pieces.length - 1;
|
|
2314
|
+
};
|
|
2315
|
+
const common = [
|
|
2316
|
+
add(tree.kind),
|
|
2317
|
+
add(tree.round),
|
|
2318
|
+
add(Uint8Array.from(tree.player, (p) => p < 0 ? 255 : p)),
|
|
2319
|
+
add(tree.firstEdge),
|
|
2320
|
+
add(tree.numEdges),
|
|
2321
|
+
add(tree.edgeChild),
|
|
2322
|
+
add(tree.payoff),
|
|
2323
|
+
add(layout.offset),
|
|
2324
|
+
add(layout.rowStart),
|
|
2325
|
+
add(active.roundBase),
|
|
2326
|
+
add(active.start),
|
|
2327
|
+
add(Int32Array.from(active.count)),
|
|
2328
|
+
add(active.cardA),
|
|
2329
|
+
add(active.cardB),
|
|
2330
|
+
add(active.strength),
|
|
2331
|
+
add(active.tieStart),
|
|
2332
|
+
add(active.ties),
|
|
2333
|
+
add(upRound),
|
|
2334
|
+
add(upStart),
|
|
2335
|
+
add(hands.up),
|
|
2336
|
+
add(hands.sameStart),
|
|
2337
|
+
add(hands.same),
|
|
2338
|
+
add(childRound),
|
|
2339
|
+
add(childStart),
|
|
2340
|
+
add(orbitRound),
|
|
2341
|
+
add(orbitStart),
|
|
2342
|
+
add(input.runoutWeight),
|
|
2343
|
+
add(null, layout.totalSlots * 4),
|
|
2344
|
+
// regret
|
|
2345
|
+
add(null, layout.totalSlots * 4)
|
|
2346
|
+
// strategy sums
|
|
2347
|
+
];
|
|
2348
|
+
const REGRET = common[27];
|
|
2349
|
+
const SUMS = common[28];
|
|
2350
|
+
const own = Array.from({ length: threads }, () => ({
|
|
2351
|
+
buffers: add(null, depths * depthBytes),
|
|
2352
|
+
cardSums: add(null, 52 * 8 + stride * 8),
|
|
2353
|
+
rootMe: add(null, rowBytes),
|
|
2354
|
+
rootOpp: add(null, rowBytes),
|
|
2355
|
+
header: add(null, 40 * 4)
|
|
2356
|
+
}));
|
|
2357
|
+
const entries = pool ? pool.plan.entryNodes.length : 0;
|
|
2358
|
+
const entryIndexOf = pool ? add(pool.plan.entryIndexOf) : -1;
|
|
2359
|
+
const reach = pool ? add(null, entries * 2 * rowBytes) : -1;
|
|
2360
|
+
const values = pool ? add(null, entries * rowBytes) : -1;
|
|
2361
|
+
const partials = pool ? add(null, (threads - 1) * entries * rowBytes) : -1;
|
|
2362
|
+
const offsets = [];
|
|
2363
|
+
let total = 64;
|
|
2364
|
+
for (const piece of pieces) {
|
|
2365
|
+
offsets.push(total);
|
|
2366
|
+
total += piece.bytes;
|
|
2367
|
+
}
|
|
2368
|
+
if (total > 4294901760) return null;
|
|
2369
|
+
const pages = Math.ceil(total / 65536) + 1;
|
|
2370
|
+
const memory = shared ? new wasm2.Memory({ initial: pages, maximum: pages, shared: true }) : new wasm2.Memory({ initial: pages });
|
|
2371
|
+
const bytes = new Uint8Array(memory.buffer);
|
|
2372
|
+
pieces.forEach((piece, i) => {
|
|
2373
|
+
if (piece.data) bytes.set(new Uint8Array(piece.data.buffer, piece.data.byteOffset, piece.data.byteLength), offsets[i]);
|
|
2374
|
+
});
|
|
2375
|
+
for (const mine of own) {
|
|
2376
|
+
const head = new Uint32Array(memory.buffer, offsets[mine.header], 40);
|
|
2377
|
+
common.forEach((slot, i) => head[i] = offsets[slot]);
|
|
2378
|
+
head[29] = offsets[mine.buffers];
|
|
2379
|
+
head[30] = depthBytes;
|
|
2380
|
+
head[31] = rowBytes;
|
|
2381
|
+
head[32] = offsets[mine.cardSums];
|
|
2382
|
+
head[33] = input.chipScale;
|
|
2383
|
+
}
|
|
2384
|
+
const instance = new wasm2.Instance(compiledModule, { env: { memory, abort: () => {
|
|
2385
|
+
throw new Error("engine abort");
|
|
2386
|
+
} } });
|
|
2387
|
+
const exports = instance.exports;
|
|
2388
|
+
exports.init(offsets[own[0].header]);
|
|
2389
|
+
exports.setMaxActions(maxActions);
|
|
2390
|
+
const regret = new Float32Array(memory.buffer, offsets[REGRET], layout.totalSlots);
|
|
2391
|
+
const strategySum = new Float32Array(memory.buffer, offsets[SUMS], layout.totalSlots);
|
|
2392
|
+
const me = new Float32Array(memory.buffer, offsets[own[0].rootMe], stride);
|
|
2393
|
+
const opp = new Float32Array(memory.buffer, offsets[own[0].rootOpp], stride);
|
|
2394
|
+
const result = new Float64Array(COMBOS);
|
|
2395
|
+
const rootList = (player) => {
|
|
2396
|
+
const slot = active.roundBase[0] * 2 + player;
|
|
2397
|
+
return [active.start[slot], active.count[slot]];
|
|
2398
|
+
};
|
|
2399
|
+
const settingsFor = (mode, iterWeight, dcfr) => {
|
|
2400
|
+
if (mode === Mode.Train && dcfr) {
|
|
2401
|
+
const { keepPositive, keepNegative, keepSum } = dcfrFactors(iterWeight);
|
|
2402
|
+
return [keepPositive, keepNegative, keepSum, 1, 0];
|
|
2403
|
+
}
|
|
2404
|
+
return [1, 1, 1, iterWeight, dcfr ? 0 : 1];
|
|
2405
|
+
};
|
|
2406
|
+
let control = null;
|
|
2407
|
+
let settings = null;
|
|
2408
|
+
const workers = [];
|
|
2409
|
+
let failure = null;
|
|
2410
|
+
if (pool) {
|
|
2411
|
+
const plan = pool.plan;
|
|
2412
|
+
const controlBuffer = new SharedArrayBuffer(ENGINE_CONTROL.size * 4);
|
|
2413
|
+
const settingsBuffer = new SharedArrayBuffer(8 * 8);
|
|
2414
|
+
control = new Int32Array(controlBuffer);
|
|
2415
|
+
settings = new Float64Array(settingsBuffer);
|
|
2416
|
+
exports.setExchange(offsets[entryIndexOf], offsets[reach], offsets[values], stride);
|
|
2417
|
+
for (let w = 1; w < threads; w++) {
|
|
2418
|
+
const setup = {
|
|
2419
|
+
memory,
|
|
2420
|
+
module: compiledModule,
|
|
2421
|
+
header: offsets[own[w].header],
|
|
2422
|
+
maxActions,
|
|
2423
|
+
exchange: [offsets[entryIndexOf], offsets[reach], offsets[values], stride],
|
|
2424
|
+
shard: [plan.round, plan.bounds[w], plan.bounds[w + 1]],
|
|
2425
|
+
entryNodes: plan.entryNodes,
|
|
2426
|
+
rootMe: offsets[own[w].rootMe],
|
|
2427
|
+
rootOpp: offsets[own[w].rootOpp],
|
|
2428
|
+
partial: offsets[partials] + (w - 1) * entries * rowBytes,
|
|
2429
|
+
stride,
|
|
2430
|
+
control: controlBuffer,
|
|
2431
|
+
settings: settingsBuffer
|
|
2432
|
+
};
|
|
2433
|
+
workers.push(pool.spawn(setup, (error) => {
|
|
2434
|
+
failure ??= error;
|
|
2435
|
+
Atomics.store(control, ENGINE_CONTROL.ready, threads);
|
|
2436
|
+
Atomics.add(control, ENGINE_CONTROL.done, threads);
|
|
2437
|
+
Atomics.notify(control, ENGINE_CONTROL.done);
|
|
2438
|
+
Atomics.notify(control, ENGINE_CONTROL.ready);
|
|
2439
|
+
}));
|
|
2440
|
+
}
|
|
2441
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2442
|
+
for (; ; ) {
|
|
2443
|
+
const ready = Atomics.load(control, ENGINE_CONTROL.ready);
|
|
2444
|
+
if (ready >= threads - 1 || failure) break;
|
|
2445
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2446
|
+
else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
|
|
2447
|
+
}
|
|
2448
|
+
if (failure) {
|
|
2449
|
+
for (const worker of workers) worker.terminate();
|
|
2450
|
+
throw failure;
|
|
2451
|
+
}
|
|
2452
|
+
}
|
|
2453
|
+
const run = (mode, traverser, iterWeight, dcfr) => {
|
|
2454
|
+
for (const player of [0, 1]) {
|
|
2455
|
+
const [from, count2] = rootList(player);
|
|
2456
|
+
const into = player === traverser ? me : opp;
|
|
2457
|
+
const weights = input.players[player].weights;
|
|
2458
|
+
for (let i = 0; i < count2; i++) into[i] = weights[active.list[from + i]];
|
|
2459
|
+
}
|
|
2460
|
+
const [positive, negative, sum, weight, clamp] = settingsFor(mode, iterWeight, dcfr);
|
|
2461
|
+
let at;
|
|
2462
|
+
if (!pool) {
|
|
2463
|
+
at = exports.run(mode, traverser, offsets[own[0].rootMe], offsets[own[0].rootOpp], positive, negative, sum, weight, clamp);
|
|
2464
|
+
} else {
|
|
2465
|
+
const plan = pool.plan;
|
|
2466
|
+
exports.setShard(plan.round, 0, 0);
|
|
2467
|
+
exports.setPhase(1, 0);
|
|
2468
|
+
exports.run(mode, traverser, offsets[own[0].rootMe], offsets[own[0].rootOpp], positive, negative, sum, weight, clamp);
|
|
2469
|
+
settings.set([positive, negative, sum, weight, clamp]);
|
|
2470
|
+
Atomics.store(control, ENGINE_CONTROL.done, 0);
|
|
2471
|
+
Atomics.store(control, ENGINE_CONTROL.mode, mode);
|
|
2472
|
+
Atomics.store(control, ENGINE_CONTROL.traverser, traverser);
|
|
2473
|
+
Atomics.store(control, ENGINE_CONTROL.command, 0);
|
|
2474
|
+
Atomics.add(control, ENGINE_CONTROL.generation, 1);
|
|
2475
|
+
Atomics.notify(control, ENGINE_CONTROL.generation);
|
|
2476
|
+
exports.setShard(plan.round, plan.bounds[0], plan.bounds[1]);
|
|
2477
|
+
exports.setPhase(0, 1);
|
|
2478
|
+
const valueView = new Float32Array(memory.buffer, offsets[values], entries * stride);
|
|
2479
|
+
for (let entry = 0; entry < entries; entry++) {
|
|
2480
|
+
const slot = offsets[reach] + entry * 2 * rowBytes;
|
|
2481
|
+
const out = exports.runChance(mode, traverser, plan.entryNodes[entry], slot, slot + rowBytes, positive, negative, sum, weight, clamp);
|
|
2482
|
+
valueView.set(new Float32Array(memory.buffer, out, stride), entry * stride);
|
|
2483
|
+
}
|
|
2484
|
+
for (; ; ) {
|
|
2485
|
+
const done = Atomics.load(control, ENGINE_CONTROL.done);
|
|
2486
|
+
if (done >= threads - 1 || failure) break;
|
|
2487
|
+
Atomics.wait(control, ENGINE_CONTROL.done, done, 50);
|
|
2488
|
+
}
|
|
2489
|
+
if (failure) throw failure;
|
|
2490
|
+
const partialView = new Float32Array(memory.buffer, offsets[partials], (threads - 1) * entries * stride);
|
|
2491
|
+
for (let w = 0; w < threads - 1; w++) {
|
|
2492
|
+
for (let i = 0; i < entries * stride; i++) valueView[i] += partialView[w * entries * stride + i];
|
|
2493
|
+
}
|
|
2494
|
+
exports.setShard(plan.round, 0, 0);
|
|
2495
|
+
exports.setPhase(2, 1);
|
|
2496
|
+
at = exports.run(mode, traverser, offsets[own[0].rootMe], offsets[own[0].rootOpp], positive, negative, sum, weight, clamp);
|
|
2497
|
+
exports.setPhase(0, 1);
|
|
2498
|
+
exports.setShard(-1, 0, 0);
|
|
2499
|
+
}
|
|
2500
|
+
const [, count] = rootList(traverser);
|
|
2501
|
+
const values32 = new Float32Array(memory.buffer, at, count);
|
|
2502
|
+
for (let i = 0; i < count; i++) result[i] = values32[i];
|
|
2503
|
+
return result;
|
|
2504
|
+
};
|
|
2505
|
+
return {
|
|
2506
|
+
regret,
|
|
2507
|
+
strategySum,
|
|
2508
|
+
threads,
|
|
2509
|
+
root(dcfr) {
|
|
2510
|
+
return (mode, traverser, iterWeight) => run(mode, traverser, iterWeight, dcfr);
|
|
2511
|
+
},
|
|
2512
|
+
close() {
|
|
2513
|
+
if (!control) return;
|
|
2514
|
+
Atomics.store(control, ENGINE_CONTROL.command, 1);
|
|
2515
|
+
Atomics.add(control, ENGINE_CONTROL.generation, 1);
|
|
2516
|
+
Atomics.notify(control, ENGINE_CONTROL.generation);
|
|
2517
|
+
for (const worker of workers) worker.terminate();
|
|
2518
|
+
}
|
|
2519
|
+
};
|
|
2520
|
+
}
|
|
2521
|
+
|
|
2522
|
+
// src/warm.ts
|
|
2523
|
+
var SIZE_TOLERANCE = 1.35;
|
|
2524
|
+
var REGRET_STEPS2 = 32767;
|
|
2525
|
+
var SUM_STEPS2 = 65535;
|
|
2526
|
+
function matchNodes(to, from) {
|
|
2527
|
+
const match = new Int32Array(to.nodeCount).fill(-1);
|
|
2528
|
+
const walk2 = (a, b) => {
|
|
2529
|
+
if (to.kind[a] !== from.kind[b] || to.round[a] !== from.round[b]) return;
|
|
2530
|
+
if (to.kind[a] === NodeKind.Chance) {
|
|
2531
|
+
walk2(to.edgeChild[to.firstEdge[a]], from.edgeChild[from.firstEdge[b]]);
|
|
2532
|
+
return;
|
|
2533
|
+
}
|
|
2534
|
+
if (to.kind[a] !== NodeKind.Decision || to.player[a] !== from.player[b]) return;
|
|
2535
|
+
match[a] = b;
|
|
2536
|
+
for (let e = 0; e < to.numEdges[a]; e++) {
|
|
2537
|
+
const edge = to.firstEdge[a] + e;
|
|
2538
|
+
const other = matchEdge(to, edge, a, from, b);
|
|
2539
|
+
if (other >= 0) walk2(to.edgeChild[edge], from.edgeChild[other]);
|
|
2540
|
+
}
|
|
2541
|
+
};
|
|
2542
|
+
walk2(0, 0);
|
|
2543
|
+
return match;
|
|
2544
|
+
}
|
|
2545
|
+
function matchEdge(to, edge, node, from, other) {
|
|
2546
|
+
const kind = to.edgeAction[edge];
|
|
2547
|
+
const sized = kind === ActionKind.Bet || kind === ActionKind.Raise;
|
|
2548
|
+
const size = to.edgeTarget[edge] / to.pot[node];
|
|
2549
|
+
let best = -1;
|
|
2550
|
+
let bestGap = Infinity;
|
|
2551
|
+
for (let e = 0; e < from.numEdges[other]; e++) {
|
|
2552
|
+
const candidate = from.firstEdge[other] + e;
|
|
2553
|
+
if (from.edgeAction[candidate] !== kind) continue;
|
|
2554
|
+
if (!sized) return candidate;
|
|
2555
|
+
const gap = Math.abs(Math.log(from.edgeTarget[candidate] / from.pot[other] / size));
|
|
2556
|
+
if (gap < bestGap) {
|
|
2557
|
+
bestGap = gap;
|
|
2558
|
+
best = candidate;
|
|
2559
|
+
}
|
|
2560
|
+
}
|
|
2561
|
+
return bestGap <= Math.log(SIZE_TOLERANCE) ? best : -1;
|
|
2562
|
+
}
|
|
2563
|
+
function readBlock(store, scale, block, base, length, out) {
|
|
2564
|
+
const factor = scale ? scale[block] : 1;
|
|
2565
|
+
for (let i = 0; i < length; i++) out[i] = store[base + i] * factor;
|
|
2566
|
+
}
|
|
2567
|
+
function writeBlock(store, scale, steps, block, base, length, values) {
|
|
2568
|
+
if (!scale) {
|
|
2569
|
+
for (let i = 0; i < length; i++) store[base + i] = values[i];
|
|
2570
|
+
return;
|
|
2571
|
+
}
|
|
2572
|
+
let largest = 0;
|
|
2573
|
+
for (let i = 0; i < length; i++) {
|
|
2574
|
+
const magnitude = Math.abs(values[i]);
|
|
2575
|
+
if (magnitude > largest) largest = magnitude;
|
|
2576
|
+
}
|
|
2577
|
+
const step = largest > 0 ? steps / largest : 0;
|
|
2578
|
+
for (let i = 0; i < length; i++) store[base + i] = Math.round(values[i] * step);
|
|
2579
|
+
scale[block] = largest / steps;
|
|
2580
|
+
}
|
|
2581
|
+
function realCards(runouts, round, board) {
|
|
2582
|
+
const width = runouts.width[round];
|
|
2583
|
+
return Array.from(runouts.cards[round].subarray(board * width, (board + 1) * width));
|
|
2584
|
+
}
|
|
2585
|
+
function warmStart(to, from, averages) {
|
|
2586
|
+
const a = to.runouts.initial;
|
|
2587
|
+
const b = from.runouts.initial;
|
|
2588
|
+
if (a.length !== b.length || a.some((card, i) => card !== b[i])) {
|
|
2589
|
+
throw new Error("A warm start must come from a solve of the same board");
|
|
2590
|
+
}
|
|
2591
|
+
const match = matchNodes(to.tree, from.tree);
|
|
2592
|
+
const { tree } = to;
|
|
2593
|
+
const width = to.layout.maxActions * COMBOS;
|
|
2594
|
+
const oldRegret = new Float64Array(width);
|
|
2595
|
+
const oldSum = new Float64Array(width);
|
|
2596
|
+
const newRegret = new Float64Array(width);
|
|
2597
|
+
const newSum = new Float64Array(width);
|
|
2598
|
+
const hasRegret = to.regret.length > 0 && from.regret.length > 0;
|
|
2599
|
+
const position = new Int32Array(COMBOS).fill(-1);
|
|
2600
|
+
let matched = 0;
|
|
2601
|
+
for (const node of tree.decisionNodes) {
|
|
2602
|
+
const old = match[node];
|
|
2603
|
+
if (old < 0) continue;
|
|
2604
|
+
matched++;
|
|
2605
|
+
const round = tree.round[node];
|
|
2606
|
+
const owner = tree.player[node];
|
|
2607
|
+
const actions = tree.numEdges[node];
|
|
2608
|
+
const oldActions = from.tree.numEdges[old];
|
|
2609
|
+
const actionOf = new Int32Array(actions).fill(-1);
|
|
2610
|
+
for (let e = 0; e < actions; e++) {
|
|
2611
|
+
const other = matchEdge(tree, tree.firstEdge[node] + e, node, from.tree, old);
|
|
2612
|
+
if (other >= 0) actionOf[e] = other - from.tree.firstEdge[old];
|
|
2613
|
+
}
|
|
2614
|
+
for (let board = 0; board < to.runouts.counts[round]; board++) {
|
|
2615
|
+
const resolved = resolveBoard(from.runouts, realCards(to.runouts, round, board));
|
|
2616
|
+
const oldSlot = (from.active.roundBase[round] + resolved.board) * 2 + owner;
|
|
2617
|
+
const oldFrom = from.active.start[oldSlot];
|
|
2618
|
+
const oldCount = from.active.count[oldSlot];
|
|
2619
|
+
const oldBlock = from.layout.blockOffset[old] + resolved.board;
|
|
2620
|
+
const oldBase = from.layout.offset[old] + oldActions * from.layout.rowStart[oldSlot];
|
|
2621
|
+
const oldLength = oldActions * oldCount;
|
|
2622
|
+
if (hasRegret) readBlock(from.regret, from.regretScale, oldBlock, oldBase, oldLength, oldRegret);
|
|
2623
|
+
readBlock(from.strategySum, from.sumScale, oldBlock, oldBase, oldLength, oldSum);
|
|
2624
|
+
for (let j = 0; j < oldCount; j++) position[from.active.list[oldFrom + j]] = j;
|
|
2625
|
+
const newSlot = (to.active.roundBase[round] + board) * 2 + owner;
|
|
2626
|
+
const newFrom = to.active.start[newSlot];
|
|
2627
|
+
const count = to.active.count[newSlot];
|
|
2628
|
+
const length = actions * count;
|
|
2629
|
+
newRegret.fill(0, 0, length);
|
|
2630
|
+
newSum.fill(0, 0, length);
|
|
2631
|
+
for (let i = 0; i < count; i++) {
|
|
2632
|
+
const j = position[resolved.combos[to.active.list[newFrom + i]]];
|
|
2633
|
+
if (j < 0) continue;
|
|
2634
|
+
for (let e = 0; e < actions; e++) {
|
|
2635
|
+
const action = actionOf[e];
|
|
2636
|
+
if (action < 0) continue;
|
|
2637
|
+
newRegret[e * count + i] = oldRegret[action * oldCount + j];
|
|
2638
|
+
newSum[e * count + i] = oldSum[action * oldCount + j];
|
|
2639
|
+
}
|
|
2640
|
+
}
|
|
2641
|
+
for (let j = 0; j < oldCount; j++) position[from.active.list[oldFrom + j]] = -1;
|
|
2642
|
+
const block = to.layout.blockOffset[node] + board;
|
|
2643
|
+
const base = to.layout.offset[node] + actions * to.layout.rowStart[newSlot];
|
|
2644
|
+
if (hasRegret) writeBlock(to.regret, to.regretScale, REGRET_STEPS2, block, base, length, newRegret);
|
|
2645
|
+
if (averages) writeBlock(to.strategySum, to.sumScale, SUM_STEPS2, block, base, length, newSum);
|
|
2646
|
+
tieBlock(to, node, board);
|
|
2647
|
+
}
|
|
2648
|
+
}
|
|
2649
|
+
return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
|
|
2650
|
+
}
|
|
2651
|
+
|
|
2387
2652
|
// src/index.ts
|
|
2388
2653
|
var DEFAULT_CHIP_SCALE = 100;
|
|
2389
2654
|
var OPS_PER_SECOND = 2e8;
|
|
@@ -2522,7 +2787,7 @@ var PRECISION_BYTES = { f64: 8, f32: 4, i16: 2 };
|
|
|
2522
2787
|
function createRun(spot, options = {}) {
|
|
2523
2788
|
const maxBytes = spot.source.maxBytes ?? DEFAULT_MAX_BYTES;
|
|
2524
2789
|
const { totalSlots, bytes } = spot.estimate;
|
|
2525
|
-
const precision = options.analysisOnly ? "f32" : options.precision ?? (
|
|
2790
|
+
const precision = options.analysisOnly ? "f32" : options.precision ?? (bytes <= maxBytes ? "f32" : "i16");
|
|
2526
2791
|
const relevant = new Uint8Array(COMBOS);
|
|
2527
2792
|
for (const combo of spot.players[0].combos) relevant[combo] = 1;
|
|
2528
2793
|
for (const combo of spot.players[1].combos) relevant[combo] = 1;
|
|
@@ -2535,20 +2800,34 @@ function createRun(spot, options = {}) {
|
|
|
2535
2800
|
const width = PRECISION_BYTES[precision];
|
|
2536
2801
|
const quantised = precision === "i16";
|
|
2537
2802
|
const active = buildActiveLists(spot.runouts, spot.players, showdown);
|
|
2803
|
+
const hands = buildHandSpace(spot.runouts, spot.players, active);
|
|
2804
|
+
const engine = options.engine !== "js" && precision === "f32" && !options.analysisOnly && options.simd !== false ? createEngine(
|
|
2805
|
+
{
|
|
2806
|
+
tree: spot.tree,
|
|
2807
|
+
runouts: spot.runouts,
|
|
2808
|
+
players: spot.players,
|
|
2809
|
+
layout,
|
|
2810
|
+
active,
|
|
2811
|
+
hands,
|
|
2812
|
+
runoutWeight: weights,
|
|
2813
|
+
chipScale: spot.chipScale
|
|
2814
|
+
},
|
|
2815
|
+
plan ? { plan, threads: requested, spawn: spawnEngineWorker } : void 0
|
|
2816
|
+
) : null;
|
|
2538
2817
|
const ctx = {
|
|
2539
2818
|
tree: spot.tree,
|
|
2540
2819
|
runouts: spot.runouts,
|
|
2541
2820
|
players: spot.players,
|
|
2542
2821
|
layout,
|
|
2543
2822
|
showdown,
|
|
2544
|
-
regret: options.analysisOnly ? new Float32Array(0) : makeRegretStore(precision, allocate(layout.totalSlots * width)),
|
|
2545
|
-
strategySum: makeSumStore(precision, allocate(layout.totalSlots * width)),
|
|
2823
|
+
regret: engine ? engine.regret : options.analysisOnly ? new Float32Array(0) : makeRegretStore(precision, allocate(layout.totalSlots * width)),
|
|
2824
|
+
strategySum: engine ? engine.strategySum : makeSumStore(precision, allocate(layout.totalSlots * width)),
|
|
2546
2825
|
regretScale: quantised ? new Float64Array(allocate(layout.blocks * 8)) : null,
|
|
2547
2826
|
sumScale: quantised ? new Float64Array(allocate(layout.blocks * 8)) : null,
|
|
2548
2827
|
scratch: makeTerminalScratch(),
|
|
2549
2828
|
chipScale: spot.chipScale,
|
|
2550
2829
|
active,
|
|
2551
|
-
hands
|
|
2830
|
+
hands,
|
|
2552
2831
|
runoutWeight: weights,
|
|
2553
2832
|
shardStart: 0,
|
|
2554
2833
|
shardEnd: plan ? plan.boards : 0,
|
|
@@ -2574,17 +2853,20 @@ function createRun(spot, options = {}) {
|
|
|
2574
2853
|
offset = options.warmIteration ?? source.totalIterations;
|
|
2575
2854
|
}
|
|
2576
2855
|
const solver = makeSolver(ctx);
|
|
2577
|
-
const pool = plan ? startPool(ctx, solver, plan, { config: spot.source, dcfr: ctx.dcfr, precision, approximations: options.approximations, simd: ctx.simd }, requested) : null;
|
|
2856
|
+
const pool = plan && !engine ? startPool(ctx, solver, plan, { config: spot.source, dcfr: ctx.dcfr, precision, approximations: options.approximations, simd: ctx.simd }, requested) : null;
|
|
2578
2857
|
if (pool) solver.useRoot(pool.traverse);
|
|
2858
|
+
if (engine) solver.useRoot(engine.root(ctx.dcfr));
|
|
2859
|
+
const threadCount = pool ? pool.workers : engine ? engine.threads : 1;
|
|
2579
2860
|
let completed = 0;
|
|
2580
2861
|
return {
|
|
2581
2862
|
spot,
|
|
2582
2863
|
solver,
|
|
2583
|
-
workers:
|
|
2864
|
+
workers: threadCount,
|
|
2584
2865
|
get completed() {
|
|
2585
2866
|
return completed;
|
|
2586
2867
|
},
|
|
2587
2868
|
warmStart: warm,
|
|
2869
|
+
engine: engine ? "wasm" : "js",
|
|
2588
2870
|
get totalIterations() {
|
|
2589
2871
|
return offset + completed;
|
|
2590
2872
|
},
|
|
@@ -2596,6 +2878,7 @@ function createRun(spot, options = {}) {
|
|
|
2596
2878
|
close() {
|
|
2597
2879
|
solver.useRoot(null);
|
|
2598
2880
|
pool?.close();
|
|
2881
|
+
engine?.close();
|
|
2599
2882
|
},
|
|
2600
2883
|
exploitabilityPercent() {
|
|
2601
2884
|
return 100 * solver.exploitability() / (spot.potUnits / spot.chipScale);
|
|
@@ -2603,7 +2886,7 @@ function createRun(spot, options = {}) {
|
|
|
2603
2886
|
trueExploitabilityPercent() {
|
|
2604
2887
|
if (!spot.runouts.approximate) return this.exploitabilityPercent();
|
|
2605
2888
|
const real = createRun(defineSpot({ ...spot.source, runoutBuckets: false }), {
|
|
2606
|
-
workers:
|
|
2889
|
+
workers: threadCount,
|
|
2607
2890
|
precision
|
|
2608
2891
|
});
|
|
2609
2892
|
try {
|
|
@@ -2614,7 +2897,7 @@ function createRun(spot, options = {}) {
|
|
|
2614
2897
|
}
|
|
2615
2898
|
},
|
|
2616
2899
|
snapshot(history = [], stoppedAt = "iterations") {
|
|
2617
|
-
return makeSolution(spot, ctx, solver, completed, offset + completed, [...history], stoppedAt,
|
|
2900
|
+
return makeSolution(spot, ctx, solver, completed, offset + completed, [...history], stoppedAt, threadCount);
|
|
2618
2901
|
}
|
|
2619
2902
|
};
|
|
2620
2903
|
}
|