poker-flopsolve 0.3.0 → 0.4.0
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 +18 -0
- package/dist/browser.js +237 -204
- package/dist/browser.js.map +1 -1
- package/dist/engine-worker.js.map +1 -1
- package/dist/index.d.ts +25 -8
- package/dist/index.js +260 -224
- package/dist/index.js.map +1 -1
- package/dist/worker.js +42 -19
- package/dist/worker.js.map +1 -1
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -107,6 +107,24 @@ defineSpot({ ..., board: 'Qs Jh 4d',
|
|
|
107
107
|
|
|
108
108
|
A subgame keeps the rounds from its own onwards.
|
|
109
109
|
|
|
110
|
+
### Betting per player
|
|
111
|
+
|
|
112
|
+
Every betting setting — `betSizes`, `raiseSizes`, `maxRaises`, `allowAllIn`,
|
|
113
|
+
`allInThreshold` — can also be given apart for each player, each side in its usual form:
|
|
114
|
+
|
|
115
|
+
```ts
|
|
116
|
+
defineSpot({ ...,
|
|
117
|
+
betSizes: { oop: [[0.33]], ip: [[0.5, 1.25]] }, // OOP bets small, IP bets half or overbets
|
|
118
|
+
maxRaises: { oop: 2, ip: 1 }, // only OOP may raise a bet
|
|
119
|
+
allowAllIn: { oop: false, ip: true },
|
|
120
|
+
});
|
|
121
|
+
```
|
|
122
|
+
|
|
123
|
+
Settings only shape the betting tree, which is built once before solving, so this costs
|
|
124
|
+
nothing per iteration: the same game given plainly or per player solves at the same
|
|
125
|
+
speed, and asymmetric sizes cost exactly what their tree does. With `maxRaises` apart, a
|
|
126
|
+
player may bet or raise only while the round's aggressions are under their own limit.
|
|
127
|
+
|
|
110
128
|
### Trimming the tree
|
|
111
129
|
|
|
112
130
|
Tree size multiplies everything else, so three switches cut the lines that cost the most
|
package/dist/browser.js
CHANGED
|
@@ -79,6 +79,15 @@ function formatCombo(combo) {
|
|
|
79
79
|
}
|
|
80
80
|
|
|
81
81
|
// src/tree.ts
|
|
82
|
+
function isPerPlayer(value) {
|
|
83
|
+
return typeof value === "object" && value !== null && !Array.isArray(value) && "oop" in value && "ip" in value;
|
|
84
|
+
}
|
|
85
|
+
function forPlayer(value, player) {
|
|
86
|
+
return isPerPlayer(value) ? player === 0 ? value.oop : value.ip : value;
|
|
87
|
+
}
|
|
88
|
+
function mapPlayers(value, f) {
|
|
89
|
+
return isPerPlayer(value) ? { oop: f(value.oop), ip: f(value.ip) } : f(value);
|
|
90
|
+
}
|
|
82
91
|
function raisesPerRound(sizes) {
|
|
83
92
|
return sizes.length > 0 && Array.isArray(sizes[0]);
|
|
84
93
|
}
|
|
@@ -139,14 +148,25 @@ function buildTree(config, runouts) {
|
|
|
139
148
|
const edgeChild = [];
|
|
140
149
|
const { potUnits, stackUnits, chipScale, minRaiseUnits } = config;
|
|
141
150
|
const rounds = runouts.rounds;
|
|
142
|
-
const
|
|
143
|
-
const
|
|
151
|
+
const players = [0, 1];
|
|
152
|
+
const maxRaises = players.map((p) => {
|
|
153
|
+
const value = forPlayer(config.maxRaises, p);
|
|
154
|
+
return perRound(value, Array.isArray(value), rounds, "maxRaises");
|
|
155
|
+
});
|
|
156
|
+
const allowAllIn = players.map((p) => {
|
|
157
|
+
const value = forPlayer(config.allowAllIn, p);
|
|
158
|
+
return perRound(value, Array.isArray(value), rounds, "allowAllIn");
|
|
159
|
+
});
|
|
144
160
|
const merge = config.mergeSizes ?? 0;
|
|
145
|
-
const raiseSizes =
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
const
|
|
161
|
+
const raiseSizes = players.map((p) => {
|
|
162
|
+
const value = forPlayer(config.raiseSizes, p);
|
|
163
|
+
return value ? perRound(value, raisesPerRound(value), rounds, "raiseSizes").map((row) => mergeBetSizes(row, merge)) : null;
|
|
164
|
+
});
|
|
165
|
+
const betSizes = players.map((p) => forPlayer(config.betSizes, p).map((row) => mergeBetSizes(row, merge)));
|
|
166
|
+
const threshold = players.map((p) => {
|
|
167
|
+
const value = forPlayer(config.allInThreshold, p) ?? 0;
|
|
168
|
+
return perRound(value, Array.isArray(value), rounds, "allInThreshold");
|
|
169
|
+
});
|
|
150
170
|
const noDonk = perRound(config.noDonk ?? false, Array.isArray(config.noDonk), rounds, "noDonk");
|
|
151
171
|
const half = Math.round(potUnits / 2);
|
|
152
172
|
const addNode = (nodeKind, nodePlayer, nodeRound, nodePot, nodePayoff) => {
|
|
@@ -225,13 +245,14 @@ function buildTree(config, runouts) {
|
|
|
225
245
|
});
|
|
226
246
|
const cap = Math.min(stackUnits, theirs + (stackUnits - theirs));
|
|
227
247
|
const donk = noDonk[state.round] && me === 0 && owed === 0 && state.aggressions === 0 && state.previousAggressor === 1;
|
|
228
|
-
if (state.aggressions < maxRaises[state.round] && myRemaining > owed && !donk) {
|
|
248
|
+
if (state.aggressions < maxRaises[me][state.round] && myRemaining > owed && !donk) {
|
|
229
249
|
const seen = /* @__PURE__ */ new Set();
|
|
230
|
-
const
|
|
231
|
-
|
|
250
|
+
const myRaises = raiseSizes[me];
|
|
251
|
+
const sizes = owed > 0 && myRaises ? [...myRaises[state.round]] : [...betSizes[me][state.round] ?? []].filter((size) => !(typeof size === "object" && "times" in size));
|
|
252
|
+
if (allowAllIn[me][state.round]) sizes.push("allin");
|
|
232
253
|
for (const size of sizes) {
|
|
233
254
|
let target = resolveTarget(size, state, cap);
|
|
234
|
-
if (target !== null && threshold[state.round] > 0 && target - mine >= threshold[state.round] * myRemaining) {
|
|
255
|
+
if (target !== null && threshold[me][state.round] > 0 && target - mine >= threshold[me][state.round] * myRemaining) {
|
|
235
256
|
target = cap;
|
|
236
257
|
}
|
|
237
258
|
if (target === null || seen.has(target)) continue;
|
|
@@ -2084,6 +2105,189 @@ var ENGINE_WASM = "AGFzbQEAAAABTglgAX8AYAZ/f39/f38Bf2AFf39/f38AYAd/f39/f3x/AGADf
|
|
|
2084
2105
|
// src/wasm/engine-shared.ts
|
|
2085
2106
|
var ENGINE_SHARED_WASM = "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";
|
|
2086
2107
|
|
|
2108
|
+
// src/platform/browser.ts
|
|
2109
|
+
var PLATFORM = "browser";
|
|
2110
|
+
var THREADS_AVAILABLE = false;
|
|
2111
|
+
var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
|
|
2112
|
+
function defaultWorkerCount() {
|
|
2113
|
+
return 1;
|
|
2114
|
+
}
|
|
2115
|
+
function spawnWorker(_setup, _onError) {
|
|
2116
|
+
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2117
|
+
}
|
|
2118
|
+
function spawnEngineWorker(_setup, _onError) {
|
|
2119
|
+
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2120
|
+
}
|
|
2121
|
+
|
|
2122
|
+
// src/parallel.ts
|
|
2123
|
+
var CONTROL = {
|
|
2124
|
+
generation: 0,
|
|
2125
|
+
done: 1,
|
|
2126
|
+
command: 2,
|
|
2127
|
+
traverser: 3,
|
|
2128
|
+
iterWeight: 4,
|
|
2129
|
+
ready: 5,
|
|
2130
|
+
mode: 6,
|
|
2131
|
+
size: 8
|
|
2132
|
+
};
|
|
2133
|
+
var COMMAND = { work: 0, exit: 1 };
|
|
2134
|
+
var WORKER_START_MS = 3e4;
|
|
2135
|
+
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.";
|
|
2136
|
+
function planShards(tree, runouts, workers) {
|
|
2137
|
+
if (workers < 2) return null;
|
|
2138
|
+
let round = -1;
|
|
2139
|
+
for (let r = 1; r < runouts.rounds; r++) {
|
|
2140
|
+
if (runouts.counts[r] > 1) {
|
|
2141
|
+
round = r;
|
|
2142
|
+
break;
|
|
2143
|
+
}
|
|
2144
|
+
}
|
|
2145
|
+
if (round < 0) return null;
|
|
2146
|
+
const boards = runouts.counts[round];
|
|
2147
|
+
if (boards < workers * 2) return null;
|
|
2148
|
+
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2149
|
+
const entryNodes = [];
|
|
2150
|
+
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2151
|
+
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2152
|
+
if (tree.round[node] + 1 !== round) continue;
|
|
2153
|
+
entryIndexOf[node] = entryNodes.length;
|
|
2154
|
+
entryNodes.push(node);
|
|
2155
|
+
}
|
|
2156
|
+
if (entryNodes.length === 0) return null;
|
|
2157
|
+
const bounds = new Int32Array(workers + 1);
|
|
2158
|
+
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2159
|
+
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2160
|
+
}
|
|
2161
|
+
function startPool(ctx, solver, plan, payload, workers) {
|
|
2162
|
+
const entryCount = plan.entryNodes.length;
|
|
2163
|
+
const spawned = workers - 1;
|
|
2164
|
+
const reachFloats = entryCount * 2 * COMBOS;
|
|
2165
|
+
const partialFloats = spawned * entryCount * COMBOS;
|
|
2166
|
+
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2167
|
+
const exchange = new Float64Array(exchangeBuffer);
|
|
2168
|
+
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2169
|
+
const control = new Int32Array(controlBuffer);
|
|
2170
|
+
const threads = [];
|
|
2171
|
+
let failure = null;
|
|
2172
|
+
for (let w = 0; w < spawned; w++) {
|
|
2173
|
+
const setup = {
|
|
2174
|
+
workerId: w,
|
|
2175
|
+
payload,
|
|
2176
|
+
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2177
|
+
shardStart: plan.bounds[w + 1],
|
|
2178
|
+
shardEnd: plan.bounds[w + 2],
|
|
2179
|
+
regret: ctx.regret.buffer,
|
|
2180
|
+
strategySum: ctx.strategySum.buffer,
|
|
2181
|
+
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2182
|
+
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2183
|
+
control: controlBuffer,
|
|
2184
|
+
exchange: exchangeBuffer,
|
|
2185
|
+
entryCount
|
|
2186
|
+
};
|
|
2187
|
+
const thread = spawnWorker(setup, (error) => {
|
|
2188
|
+
failure ??= error;
|
|
2189
|
+
Atomics.store(control, CONTROL.ready, spawned);
|
|
2190
|
+
Atomics.add(control, CONTROL.done, spawned);
|
|
2191
|
+
Atomics.notify(control, CONTROL.done);
|
|
2192
|
+
Atomics.notify(control, CONTROL.ready);
|
|
2193
|
+
});
|
|
2194
|
+
threads.push(thread);
|
|
2195
|
+
}
|
|
2196
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2197
|
+
for (; ; ) {
|
|
2198
|
+
const ready = Atomics.load(control, CONTROL.ready);
|
|
2199
|
+
if (ready >= spawned || failure) break;
|
|
2200
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2201
|
+
else Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2202
|
+
}
|
|
2203
|
+
if (failure) {
|
|
2204
|
+
for (const thread of threads) thread.terminate();
|
|
2205
|
+
throw failure;
|
|
2206
|
+
}
|
|
2207
|
+
const total = new Float64Array(COMBOS);
|
|
2208
|
+
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2209
|
+
const mainReachMe = new Float64Array(COMBOS);
|
|
2210
|
+
const mainReachOpp = new Float64Array(COMBOS);
|
|
2211
|
+
const dispatch = (mode, traverser, iterWeight) => {
|
|
2212
|
+
Atomics.store(control, CONTROL.done, 0);
|
|
2213
|
+
Atomics.store(control, CONTROL.mode, mode);
|
|
2214
|
+
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2215
|
+
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2216
|
+
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2217
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2218
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2219
|
+
const fullStart = ctx.shardStart;
|
|
2220
|
+
const fullEnd = ctx.shardEnd;
|
|
2221
|
+
ctx.shardStart = plan.bounds[0];
|
|
2222
|
+
ctx.shardEnd = plan.bounds[1];
|
|
2223
|
+
ctx.applyUpdates = true;
|
|
2224
|
+
try {
|
|
2225
|
+
for (let entry = 0; entry < entryCount; entry++) {
|
|
2226
|
+
for (let i = 0; i < COMBOS; i++) {
|
|
2227
|
+
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2228
|
+
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2229
|
+
}
|
|
2230
|
+
const value = solver.traverseChance(
|
|
2231
|
+
mode,
|
|
2232
|
+
traverser,
|
|
2233
|
+
iterWeight,
|
|
2234
|
+
plan.entryNodes[entry],
|
|
2235
|
+
mainReachMe,
|
|
2236
|
+
mainReachOpp
|
|
2237
|
+
);
|
|
2238
|
+
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2239
|
+
}
|
|
2240
|
+
} finally {
|
|
2241
|
+
ctx.shardStart = fullStart;
|
|
2242
|
+
ctx.shardEnd = fullEnd;
|
|
2243
|
+
}
|
|
2244
|
+
for (; ; ) {
|
|
2245
|
+
const done = Atomics.load(control, CONTROL.done);
|
|
2246
|
+
if (done >= spawned) break;
|
|
2247
|
+
if (failure) throw failure;
|
|
2248
|
+
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2249
|
+
}
|
|
2250
|
+
if (failure) throw failure;
|
|
2251
|
+
};
|
|
2252
|
+
return {
|
|
2253
|
+
workers,
|
|
2254
|
+
traverse(mode, traverser, iterWeight) {
|
|
2255
|
+
ctx.applyUpdates = false;
|
|
2256
|
+
ctx.chanceOverride = null;
|
|
2257
|
+
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2258
|
+
const entry = plan.entryIndexOf[node];
|
|
2259
|
+
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2260
|
+
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2261
|
+
};
|
|
2262
|
+
try {
|
|
2263
|
+
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2264
|
+
} finally {
|
|
2265
|
+
ctx.chanceCollect = null;
|
|
2266
|
+
}
|
|
2267
|
+
dispatch(mode, traverser, iterWeight);
|
|
2268
|
+
for (let w = 0; w < spawned; w++) {
|
|
2269
|
+
const base = reachFloats + w * entryCount * COMBOS;
|
|
2270
|
+
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2271
|
+
}
|
|
2272
|
+
ctx.chanceOverride = chanceValues;
|
|
2273
|
+
ctx.applyUpdates = true;
|
|
2274
|
+
try {
|
|
2275
|
+
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2276
|
+
total.set(value.subarray(0, COMBOS));
|
|
2277
|
+
} finally {
|
|
2278
|
+
ctx.chanceOverride = null;
|
|
2279
|
+
}
|
|
2280
|
+
return total;
|
|
2281
|
+
},
|
|
2282
|
+
close() {
|
|
2283
|
+
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2284
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2285
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2286
|
+
for (const thread of threads) thread.terminate();
|
|
2287
|
+
}
|
|
2288
|
+
};
|
|
2289
|
+
}
|
|
2290
|
+
|
|
2087
2291
|
// src/engine.ts
|
|
2088
2292
|
var wasm2 = globalThis.WebAssembly;
|
|
2089
2293
|
var modules = { plain: void 0, shared: void 0 };
|
|
@@ -2255,10 +2459,12 @@ function createEngine(input, pool) {
|
|
|
2255
2459
|
Atomics.notify(control, ENGINE_CONTROL.ready);
|
|
2256
2460
|
}));
|
|
2257
2461
|
}
|
|
2462
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2258
2463
|
for (; ; ) {
|
|
2259
2464
|
const ready = Atomics.load(control, ENGINE_CONTROL.ready);
|
|
2260
2465
|
if (ready >= threads - 1 || failure) break;
|
|
2261
|
-
|
|
2466
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2467
|
+
else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
|
|
2262
2468
|
}
|
|
2263
2469
|
if (failure) {
|
|
2264
2470
|
for (const worker of workers) worker.terminate();
|
|
@@ -2464,185 +2670,6 @@ function warmStart(to, from, averages) {
|
|
|
2464
2670
|
return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
|
|
2465
2671
|
}
|
|
2466
2672
|
|
|
2467
|
-
// src/platform/browser.ts
|
|
2468
|
-
var PLATFORM = "browser";
|
|
2469
|
-
var THREADS_AVAILABLE = false;
|
|
2470
|
-
var DEFAULT_MAX_BYTES = 512 * 1024 * 1024;
|
|
2471
|
-
function defaultWorkerCount() {
|
|
2472
|
-
return 1;
|
|
2473
|
-
}
|
|
2474
|
-
function spawnWorker(_setup, _onError) {
|
|
2475
|
-
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2476
|
-
}
|
|
2477
|
-
function spawnEngineWorker(_setup, _onError) {
|
|
2478
|
-
throw new Error("Worker threads are only available in the Node build; use workers: 1 in the browser");
|
|
2479
|
-
}
|
|
2480
|
-
|
|
2481
|
-
// src/parallel.ts
|
|
2482
|
-
var CONTROL = {
|
|
2483
|
-
generation: 0,
|
|
2484
|
-
done: 1,
|
|
2485
|
-
command: 2,
|
|
2486
|
-
traverser: 3,
|
|
2487
|
-
iterWeight: 4,
|
|
2488
|
-
ready: 5,
|
|
2489
|
-
mode: 6,
|
|
2490
|
-
size: 8
|
|
2491
|
-
};
|
|
2492
|
-
var COMMAND = { work: 0, exit: 1 };
|
|
2493
|
-
function planShards(tree, runouts, workers) {
|
|
2494
|
-
if (workers < 2) return null;
|
|
2495
|
-
let round = -1;
|
|
2496
|
-
for (let r = 1; r < runouts.rounds; r++) {
|
|
2497
|
-
if (runouts.counts[r] > 1) {
|
|
2498
|
-
round = r;
|
|
2499
|
-
break;
|
|
2500
|
-
}
|
|
2501
|
-
}
|
|
2502
|
-
if (round < 0) return null;
|
|
2503
|
-
const boards = runouts.counts[round];
|
|
2504
|
-
if (boards < workers * 2) return null;
|
|
2505
|
-
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2506
|
-
const entryNodes = [];
|
|
2507
|
-
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2508
|
-
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2509
|
-
if (tree.round[node] + 1 !== round) continue;
|
|
2510
|
-
entryIndexOf[node] = entryNodes.length;
|
|
2511
|
-
entryNodes.push(node);
|
|
2512
|
-
}
|
|
2513
|
-
if (entryNodes.length === 0) return null;
|
|
2514
|
-
const bounds = new Int32Array(workers + 1);
|
|
2515
|
-
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2516
|
-
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2517
|
-
}
|
|
2518
|
-
function startPool(ctx, solver, plan, payload, workers) {
|
|
2519
|
-
const entryCount = plan.entryNodes.length;
|
|
2520
|
-
const spawned = workers - 1;
|
|
2521
|
-
const reachFloats = entryCount * 2 * COMBOS;
|
|
2522
|
-
const partialFloats = spawned * entryCount * COMBOS;
|
|
2523
|
-
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2524
|
-
const exchange = new Float64Array(exchangeBuffer);
|
|
2525
|
-
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2526
|
-
const control = new Int32Array(controlBuffer);
|
|
2527
|
-
const threads = [];
|
|
2528
|
-
let failure = null;
|
|
2529
|
-
for (let w = 0; w < spawned; w++) {
|
|
2530
|
-
const setup = {
|
|
2531
|
-
workerId: w,
|
|
2532
|
-
payload,
|
|
2533
|
-
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2534
|
-
shardStart: plan.bounds[w + 1],
|
|
2535
|
-
shardEnd: plan.bounds[w + 2],
|
|
2536
|
-
regret: ctx.regret.buffer,
|
|
2537
|
-
strategySum: ctx.strategySum.buffer,
|
|
2538
|
-
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2539
|
-
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2540
|
-
control: controlBuffer,
|
|
2541
|
-
exchange: exchangeBuffer,
|
|
2542
|
-
entryCount
|
|
2543
|
-
};
|
|
2544
|
-
const thread = spawnWorker(setup, (error) => {
|
|
2545
|
-
failure ??= error;
|
|
2546
|
-
Atomics.store(control, CONTROL.ready, spawned);
|
|
2547
|
-
Atomics.add(control, CONTROL.done, spawned);
|
|
2548
|
-
Atomics.notify(control, CONTROL.done);
|
|
2549
|
-
Atomics.notify(control, CONTROL.ready);
|
|
2550
|
-
});
|
|
2551
|
-
threads.push(thread);
|
|
2552
|
-
}
|
|
2553
|
-
for (; ; ) {
|
|
2554
|
-
const ready = Atomics.load(control, CONTROL.ready);
|
|
2555
|
-
if (ready >= spawned || failure) break;
|
|
2556
|
-
Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2557
|
-
}
|
|
2558
|
-
if (failure) {
|
|
2559
|
-
for (const thread of threads) thread.terminate();
|
|
2560
|
-
throw failure;
|
|
2561
|
-
}
|
|
2562
|
-
const total = new Float64Array(COMBOS);
|
|
2563
|
-
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2564
|
-
const mainReachMe = new Float64Array(COMBOS);
|
|
2565
|
-
const mainReachOpp = new Float64Array(COMBOS);
|
|
2566
|
-
const dispatch = (mode, traverser, iterWeight) => {
|
|
2567
|
-
Atomics.store(control, CONTROL.done, 0);
|
|
2568
|
-
Atomics.store(control, CONTROL.mode, mode);
|
|
2569
|
-
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2570
|
-
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2571
|
-
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2572
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2573
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2574
|
-
const fullStart = ctx.shardStart;
|
|
2575
|
-
const fullEnd = ctx.shardEnd;
|
|
2576
|
-
ctx.shardStart = plan.bounds[0];
|
|
2577
|
-
ctx.shardEnd = plan.bounds[1];
|
|
2578
|
-
ctx.applyUpdates = true;
|
|
2579
|
-
try {
|
|
2580
|
-
for (let entry = 0; entry < entryCount; entry++) {
|
|
2581
|
-
for (let i = 0; i < COMBOS; i++) {
|
|
2582
|
-
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2583
|
-
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2584
|
-
}
|
|
2585
|
-
const value = solver.traverseChance(
|
|
2586
|
-
mode,
|
|
2587
|
-
traverser,
|
|
2588
|
-
iterWeight,
|
|
2589
|
-
plan.entryNodes[entry],
|
|
2590
|
-
mainReachMe,
|
|
2591
|
-
mainReachOpp
|
|
2592
|
-
);
|
|
2593
|
-
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2594
|
-
}
|
|
2595
|
-
} finally {
|
|
2596
|
-
ctx.shardStart = fullStart;
|
|
2597
|
-
ctx.shardEnd = fullEnd;
|
|
2598
|
-
}
|
|
2599
|
-
for (; ; ) {
|
|
2600
|
-
const done = Atomics.load(control, CONTROL.done);
|
|
2601
|
-
if (done >= spawned) break;
|
|
2602
|
-
if (failure) throw failure;
|
|
2603
|
-
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2604
|
-
}
|
|
2605
|
-
if (failure) throw failure;
|
|
2606
|
-
};
|
|
2607
|
-
return {
|
|
2608
|
-
workers,
|
|
2609
|
-
traverse(mode, traverser, iterWeight) {
|
|
2610
|
-
ctx.applyUpdates = false;
|
|
2611
|
-
ctx.chanceOverride = null;
|
|
2612
|
-
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2613
|
-
const entry = plan.entryIndexOf[node];
|
|
2614
|
-
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2615
|
-
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2616
|
-
};
|
|
2617
|
-
try {
|
|
2618
|
-
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2619
|
-
} finally {
|
|
2620
|
-
ctx.chanceCollect = null;
|
|
2621
|
-
}
|
|
2622
|
-
dispatch(mode, traverser, iterWeight);
|
|
2623
|
-
for (let w = 0; w < spawned; w++) {
|
|
2624
|
-
const base = reachFloats + w * entryCount * COMBOS;
|
|
2625
|
-
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2626
|
-
}
|
|
2627
|
-
ctx.chanceOverride = chanceValues;
|
|
2628
|
-
ctx.applyUpdates = true;
|
|
2629
|
-
try {
|
|
2630
|
-
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2631
|
-
total.set(value.subarray(0, COMBOS));
|
|
2632
|
-
} finally {
|
|
2633
|
-
ctx.chanceOverride = null;
|
|
2634
|
-
}
|
|
2635
|
-
return total;
|
|
2636
|
-
},
|
|
2637
|
-
close() {
|
|
2638
|
-
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2639
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2640
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2641
|
-
for (const thread of threads) thread.terminate();
|
|
2642
|
-
}
|
|
2643
|
-
};
|
|
2644
|
-
}
|
|
2645
|
-
|
|
2646
2673
|
// src/index.ts
|
|
2647
2674
|
var DEFAULT_CHIP_SCALE = 100;
|
|
2648
2675
|
var OPS_PER_SECOND = 2e8;
|
|
@@ -2680,12 +2707,16 @@ function defineSpot(config) {
|
|
|
2680
2707
|
const rounds = 6 - board.length;
|
|
2681
2708
|
if (config.pot <= 0) throw new Error("pot must be positive");
|
|
2682
2709
|
if (config.stack <= 0) throw new Error("stack must be positive");
|
|
2683
|
-
const
|
|
2684
|
-
|
|
2685
|
-
|
|
2686
|
-
|
|
2687
|
-
|
|
2688
|
-
|
|
2710
|
+
const rowsFor = (sizes, who) => {
|
|
2711
|
+
const expanded = sizes.length === 1 ? Array.from({ length: rounds }, () => sizes[0]) : sizes;
|
|
2712
|
+
if (expanded.length !== rounds) {
|
|
2713
|
+
throw new Error(
|
|
2714
|
+
`${who}betSizes has ${sizes.length} rows but this board has ${rounds} betting rounds; give one row per round, or a single row for all of them`
|
|
2715
|
+
);
|
|
2716
|
+
}
|
|
2717
|
+
return expanded;
|
|
2718
|
+
};
|
|
2719
|
+
const rows = isPerPlayer(config.betSizes) ? { oop: rowsFor(config.betSizes.oop, "oop "), ip: rowsFor(config.betSizes.ip, "ip ") } : rowsFor(config.betSizes, "");
|
|
2689
2720
|
const onBoard = new Set(board);
|
|
2690
2721
|
const trim = (range, who) => {
|
|
2691
2722
|
const weights = typeof range === "string" ? parseRange(range) : Float64Array.from(range);
|
|
@@ -2743,9 +2774,10 @@ function defineSpot(config) {
|
|
|
2743
2774
|
const compressedBytes = buildLayout(tree, runouts, players, 2).bytes + showdownBytes;
|
|
2744
2775
|
const suggestions = [];
|
|
2745
2776
|
if (compressedBytes > maxBytes) {
|
|
2746
|
-
const widest = Math.max(...rows.map((r) => r.length));
|
|
2777
|
+
const widest = Math.max(...[0, 1].flatMap((p) => forPlayer(rows, p).map((r) => r.length)));
|
|
2747
2778
|
if (widest > 1) suggestions.push(`use fewer bet sizes (currently up to ${widest} per round)`);
|
|
2748
|
-
|
|
2779
|
+
const raises = [0, 1].flatMap((p) => [forPlayer(config.maxRaises ?? 1, p)].flat());
|
|
2780
|
+
if (Math.max(...raises) > 1) suggestions.push(`lower maxRaises to 1`);
|
|
2749
2781
|
suggestions.push(`narrow the ranges (currently ${players[0].count} and ${players[1].count} combos)`);
|
|
2750
2782
|
if (runouts.rounds === 3) suggestions.push("solve from the turn instead of the flop");
|
|
2751
2783
|
}
|
|
@@ -3093,8 +3125,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
|
|
|
3093
3125
|
const invested = (tree.pot[node] - spot.potUnits) / 2;
|
|
3094
3126
|
const { source } = spot;
|
|
3095
3127
|
const later = (value, listed) => listed && value.length > 1 ? value.slice(round) : value;
|
|
3096
|
-
const
|
|
3097
|
-
const
|
|
3128
|
+
const laterEach = (value, listed) => value === void 0 ? void 0 : mapPlayers(value, (side) => later(side, listed(side)));
|
|
3129
|
+
const rows = laterEach(source.betSizes, () => true);
|
|
3130
|
+
const raiseRows = laterEach(source.raiseSizes, (side) => side !== void 0 && raisesPerRound(side));
|
|
3098
3131
|
return {
|
|
3099
3132
|
board: formatCards(cards),
|
|
3100
3133
|
pot: tree.pot[node] / spot.chipScale,
|
|
@@ -3103,9 +3136,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
|
|
|
3103
3136
|
ip: reachAt(node, board, 1),
|
|
3104
3137
|
betSizes: betting.betSizes ?? rows,
|
|
3105
3138
|
raiseSizes: "raiseSizes" in betting ? betting.raiseSizes : raiseRows,
|
|
3106
|
-
maxRaises: betting.maxRaises ?? (source.maxRaises
|
|
3107
|
-
allowAllIn: betting.allowAllIn ?? (source.allowAllIn
|
|
3108
|
-
allInThreshold: "allInThreshold" in betting ? betting.allInThreshold :
|
|
3139
|
+
maxRaises: betting.maxRaises ?? laterEach(source.maxRaises, Array.isArray),
|
|
3140
|
+
allowAllIn: betting.allowAllIn ?? laterEach(source.allowAllIn, Array.isArray),
|
|
3141
|
+
allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : laterEach(source.allInThreshold, Array.isArray),
|
|
3109
3142
|
noDonk: "noDonk" in betting ? betting.noDonk : source.noDonk === void 0 ? void 0 : later(source.noDonk, Array.isArray(source.noDonk)),
|
|
3110
3143
|
mergeSizes: "mergeSizes" in betting ? betting.mergeSizes : source.mergeSizes,
|
|
3111
3144
|
minWeight: source.minWeight,
|