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/dist/index.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,212 @@ 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/node.ts
|
|
2109
|
+
import { availableParallelism } from "os";
|
|
2110
|
+
import { fileURLToPath } from "url";
|
|
2111
|
+
import { Worker } from "worker_threads";
|
|
2112
|
+
var PLATFORM = "node";
|
|
2113
|
+
var THREADS_AVAILABLE = true;
|
|
2114
|
+
var DEFAULT_MAX_BYTES = 6 * 1024 * 1024 * 1024;
|
|
2115
|
+
function workerFlags() {
|
|
2116
|
+
return process.execArgv.filter((flag) => !flag.startsWith("--input-type"));
|
|
2117
|
+
}
|
|
2118
|
+
function defaultWorkerCount() {
|
|
2119
|
+
const cores = availableParallelism();
|
|
2120
|
+
return cores < 2 ? 1 : Math.max(2, cores - 1);
|
|
2121
|
+
}
|
|
2122
|
+
function spawnWorker(setup, onError) {
|
|
2123
|
+
const url = new URL(import.meta.url.endsWith(".ts") ? "../worker.ts" : "./worker.js", import.meta.url);
|
|
2124
|
+
const thread = new Worker(fileURLToPath(url), { workerData: setup, execArgv: workerFlags() });
|
|
2125
|
+
thread.on("error", onError);
|
|
2126
|
+
thread.unref();
|
|
2127
|
+
return {
|
|
2128
|
+
terminate() {
|
|
2129
|
+
void thread.terminate();
|
|
2130
|
+
}
|
|
2131
|
+
};
|
|
2132
|
+
}
|
|
2133
|
+
function spawnEngineWorker(setup, onError) {
|
|
2134
|
+
const url = new URL(import.meta.url.endsWith(".ts") ? "../engine-worker.ts" : "./engine-worker.js", import.meta.url);
|
|
2135
|
+
const thread = new Worker(fileURLToPath(url), { workerData: setup, execArgv: workerFlags() });
|
|
2136
|
+
thread.on("error", onError);
|
|
2137
|
+
thread.unref();
|
|
2138
|
+
return {
|
|
2139
|
+
terminate() {
|
|
2140
|
+
void thread.terminate();
|
|
2141
|
+
}
|
|
2142
|
+
};
|
|
2143
|
+
}
|
|
2144
|
+
|
|
2145
|
+
// src/parallel.ts
|
|
2146
|
+
var CONTROL = {
|
|
2147
|
+
generation: 0,
|
|
2148
|
+
done: 1,
|
|
2149
|
+
command: 2,
|
|
2150
|
+
traverser: 3,
|
|
2151
|
+
iterWeight: 4,
|
|
2152
|
+
ready: 5,
|
|
2153
|
+
mode: 6,
|
|
2154
|
+
size: 8
|
|
2155
|
+
};
|
|
2156
|
+
var COMMAND = { work: 0, exit: 1 };
|
|
2157
|
+
var WORKER_START_MS = 3e4;
|
|
2158
|
+
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.";
|
|
2159
|
+
function planShards(tree, runouts, workers) {
|
|
2160
|
+
if (workers < 2) return null;
|
|
2161
|
+
let round = -1;
|
|
2162
|
+
for (let r = 1; r < runouts.rounds; r++) {
|
|
2163
|
+
if (runouts.counts[r] > 1) {
|
|
2164
|
+
round = r;
|
|
2165
|
+
break;
|
|
2166
|
+
}
|
|
2167
|
+
}
|
|
2168
|
+
if (round < 0) return null;
|
|
2169
|
+
const boards = runouts.counts[round];
|
|
2170
|
+
if (boards < workers * 2) return null;
|
|
2171
|
+
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2172
|
+
const entryNodes = [];
|
|
2173
|
+
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2174
|
+
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2175
|
+
if (tree.round[node] + 1 !== round) continue;
|
|
2176
|
+
entryIndexOf[node] = entryNodes.length;
|
|
2177
|
+
entryNodes.push(node);
|
|
2178
|
+
}
|
|
2179
|
+
if (entryNodes.length === 0) return null;
|
|
2180
|
+
const bounds = new Int32Array(workers + 1);
|
|
2181
|
+
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2182
|
+
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2183
|
+
}
|
|
2184
|
+
function startPool(ctx, solver, plan, payload, workers) {
|
|
2185
|
+
const entryCount = plan.entryNodes.length;
|
|
2186
|
+
const spawned = workers - 1;
|
|
2187
|
+
const reachFloats = entryCount * 2 * COMBOS;
|
|
2188
|
+
const partialFloats = spawned * entryCount * COMBOS;
|
|
2189
|
+
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2190
|
+
const exchange = new Float64Array(exchangeBuffer);
|
|
2191
|
+
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2192
|
+
const control = new Int32Array(controlBuffer);
|
|
2193
|
+
const threads = [];
|
|
2194
|
+
let failure = null;
|
|
2195
|
+
for (let w = 0; w < spawned; w++) {
|
|
2196
|
+
const setup = {
|
|
2197
|
+
workerId: w,
|
|
2198
|
+
payload,
|
|
2199
|
+
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2200
|
+
shardStart: plan.bounds[w + 1],
|
|
2201
|
+
shardEnd: plan.bounds[w + 2],
|
|
2202
|
+
regret: ctx.regret.buffer,
|
|
2203
|
+
strategySum: ctx.strategySum.buffer,
|
|
2204
|
+
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2205
|
+
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2206
|
+
control: controlBuffer,
|
|
2207
|
+
exchange: exchangeBuffer,
|
|
2208
|
+
entryCount
|
|
2209
|
+
};
|
|
2210
|
+
const thread = spawnWorker(setup, (error) => {
|
|
2211
|
+
failure ??= error;
|
|
2212
|
+
Atomics.store(control, CONTROL.ready, spawned);
|
|
2213
|
+
Atomics.add(control, CONTROL.done, spawned);
|
|
2214
|
+
Atomics.notify(control, CONTROL.done);
|
|
2215
|
+
Atomics.notify(control, CONTROL.ready);
|
|
2216
|
+
});
|
|
2217
|
+
threads.push(thread);
|
|
2218
|
+
}
|
|
2219
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2220
|
+
for (; ; ) {
|
|
2221
|
+
const ready = Atomics.load(control, CONTROL.ready);
|
|
2222
|
+
if (ready >= spawned || failure) break;
|
|
2223
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2224
|
+
else Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2225
|
+
}
|
|
2226
|
+
if (failure) {
|
|
2227
|
+
for (const thread of threads) thread.terminate();
|
|
2228
|
+
throw failure;
|
|
2229
|
+
}
|
|
2230
|
+
const total = new Float64Array(COMBOS);
|
|
2231
|
+
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2232
|
+
const mainReachMe = new Float64Array(COMBOS);
|
|
2233
|
+
const mainReachOpp = new Float64Array(COMBOS);
|
|
2234
|
+
const dispatch = (mode, traverser, iterWeight) => {
|
|
2235
|
+
Atomics.store(control, CONTROL.done, 0);
|
|
2236
|
+
Atomics.store(control, CONTROL.mode, mode);
|
|
2237
|
+
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2238
|
+
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2239
|
+
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2240
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2241
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2242
|
+
const fullStart = ctx.shardStart;
|
|
2243
|
+
const fullEnd = ctx.shardEnd;
|
|
2244
|
+
ctx.shardStart = plan.bounds[0];
|
|
2245
|
+
ctx.shardEnd = plan.bounds[1];
|
|
2246
|
+
ctx.applyUpdates = true;
|
|
2247
|
+
try {
|
|
2248
|
+
for (let entry = 0; entry < entryCount; entry++) {
|
|
2249
|
+
for (let i = 0; i < COMBOS; i++) {
|
|
2250
|
+
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2251
|
+
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2252
|
+
}
|
|
2253
|
+
const value = solver.traverseChance(
|
|
2254
|
+
mode,
|
|
2255
|
+
traverser,
|
|
2256
|
+
iterWeight,
|
|
2257
|
+
plan.entryNodes[entry],
|
|
2258
|
+
mainReachMe,
|
|
2259
|
+
mainReachOpp
|
|
2260
|
+
);
|
|
2261
|
+
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2262
|
+
}
|
|
2263
|
+
} finally {
|
|
2264
|
+
ctx.shardStart = fullStart;
|
|
2265
|
+
ctx.shardEnd = fullEnd;
|
|
2266
|
+
}
|
|
2267
|
+
for (; ; ) {
|
|
2268
|
+
const done = Atomics.load(control, CONTROL.done);
|
|
2269
|
+
if (done >= spawned) break;
|
|
2270
|
+
if (failure) throw failure;
|
|
2271
|
+
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2272
|
+
}
|
|
2273
|
+
if (failure) throw failure;
|
|
2274
|
+
};
|
|
2275
|
+
return {
|
|
2276
|
+
workers,
|
|
2277
|
+
traverse(mode, traverser, iterWeight) {
|
|
2278
|
+
ctx.applyUpdates = false;
|
|
2279
|
+
ctx.chanceOverride = null;
|
|
2280
|
+
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2281
|
+
const entry = plan.entryIndexOf[node];
|
|
2282
|
+
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2283
|
+
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2284
|
+
};
|
|
2285
|
+
try {
|
|
2286
|
+
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2287
|
+
} finally {
|
|
2288
|
+
ctx.chanceCollect = null;
|
|
2289
|
+
}
|
|
2290
|
+
dispatch(mode, traverser, iterWeight);
|
|
2291
|
+
for (let w = 0; w < spawned; w++) {
|
|
2292
|
+
const base = reachFloats + w * entryCount * COMBOS;
|
|
2293
|
+
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2294
|
+
}
|
|
2295
|
+
ctx.chanceOverride = chanceValues;
|
|
2296
|
+
ctx.applyUpdates = true;
|
|
2297
|
+
try {
|
|
2298
|
+
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2299
|
+
total.set(value.subarray(0, COMBOS));
|
|
2300
|
+
} finally {
|
|
2301
|
+
ctx.chanceOverride = null;
|
|
2302
|
+
}
|
|
2303
|
+
return total;
|
|
2304
|
+
},
|
|
2305
|
+
close() {
|
|
2306
|
+
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2307
|
+
Atomics.add(control, CONTROL.generation, 1);
|
|
2308
|
+
Atomics.notify(control, CONTROL.generation);
|
|
2309
|
+
for (const thread of threads) thread.terminate();
|
|
2310
|
+
}
|
|
2311
|
+
};
|
|
2312
|
+
}
|
|
2313
|
+
|
|
2087
2314
|
// src/engine.ts
|
|
2088
2315
|
var wasm2 = globalThis.WebAssembly;
|
|
2089
2316
|
var modules = { plain: void 0, shared: void 0 };
|
|
@@ -2255,10 +2482,12 @@ function createEngine(input, pool) {
|
|
|
2255
2482
|
Atomics.notify(control, ENGINE_CONTROL.ready);
|
|
2256
2483
|
}));
|
|
2257
2484
|
}
|
|
2485
|
+
const deadline = Date.now() + WORKER_START_MS;
|
|
2258
2486
|
for (; ; ) {
|
|
2259
2487
|
const ready = Atomics.load(control, ENGINE_CONTROL.ready);
|
|
2260
2488
|
if (ready >= threads - 1 || failure) break;
|
|
2261
|
-
|
|
2489
|
+
if (Date.now() > deadline) failure = new Error(WORKER_START_ERROR);
|
|
2490
|
+
else Atomics.wait(control, ENGINE_CONTROL.ready, ready, 20);
|
|
2262
2491
|
}
|
|
2263
2492
|
if (failure) {
|
|
2264
2493
|
for (const worker of workers) worker.terminate();
|
|
@@ -2464,205 +2693,6 @@ function warmStart(to, from, averages) {
|
|
|
2464
2693
|
return { matchedNodes: matched, decisionNodes: tree.decisionNodes.length, averages };
|
|
2465
2694
|
}
|
|
2466
2695
|
|
|
2467
|
-
// src/platform/node.ts
|
|
2468
|
-
import { availableParallelism } from "os";
|
|
2469
|
-
import { fileURLToPath } from "url";
|
|
2470
|
-
import { Worker } from "worker_threads";
|
|
2471
|
-
var PLATFORM = "node";
|
|
2472
|
-
var THREADS_AVAILABLE = true;
|
|
2473
|
-
var DEFAULT_MAX_BYTES = 6 * 1024 * 1024 * 1024;
|
|
2474
|
-
function defaultWorkerCount() {
|
|
2475
|
-
const cores = availableParallelism();
|
|
2476
|
-
return cores < 2 ? 1 : Math.max(2, cores - 1);
|
|
2477
|
-
}
|
|
2478
|
-
function spawnWorker(setup, onError) {
|
|
2479
|
-
const url = new URL(import.meta.url.endsWith(".ts") ? "../worker.ts" : "./worker.js", import.meta.url);
|
|
2480
|
-
const thread = new Worker(fileURLToPath(url), { workerData: setup });
|
|
2481
|
-
thread.on("error", onError);
|
|
2482
|
-
thread.unref();
|
|
2483
|
-
return {
|
|
2484
|
-
terminate() {
|
|
2485
|
-
void thread.terminate();
|
|
2486
|
-
}
|
|
2487
|
-
};
|
|
2488
|
-
}
|
|
2489
|
-
function spawnEngineWorker(setup, onError) {
|
|
2490
|
-
const url = new URL(import.meta.url.endsWith(".ts") ? "../engine-worker.ts" : "./engine-worker.js", import.meta.url);
|
|
2491
|
-
const thread = new Worker(fileURLToPath(url), { workerData: setup });
|
|
2492
|
-
thread.on("error", onError);
|
|
2493
|
-
thread.unref();
|
|
2494
|
-
return {
|
|
2495
|
-
terminate() {
|
|
2496
|
-
void thread.terminate();
|
|
2497
|
-
}
|
|
2498
|
-
};
|
|
2499
|
-
}
|
|
2500
|
-
|
|
2501
|
-
// src/parallel.ts
|
|
2502
|
-
var CONTROL = {
|
|
2503
|
-
generation: 0,
|
|
2504
|
-
done: 1,
|
|
2505
|
-
command: 2,
|
|
2506
|
-
traverser: 3,
|
|
2507
|
-
iterWeight: 4,
|
|
2508
|
-
ready: 5,
|
|
2509
|
-
mode: 6,
|
|
2510
|
-
size: 8
|
|
2511
|
-
};
|
|
2512
|
-
var COMMAND = { work: 0, exit: 1 };
|
|
2513
|
-
function planShards(tree, runouts, workers) {
|
|
2514
|
-
if (workers < 2) return null;
|
|
2515
|
-
let round = -1;
|
|
2516
|
-
for (let r = 1; r < runouts.rounds; r++) {
|
|
2517
|
-
if (runouts.counts[r] > 1) {
|
|
2518
|
-
round = r;
|
|
2519
|
-
break;
|
|
2520
|
-
}
|
|
2521
|
-
}
|
|
2522
|
-
if (round < 0) return null;
|
|
2523
|
-
const boards = runouts.counts[round];
|
|
2524
|
-
if (boards < workers * 2) return null;
|
|
2525
|
-
const entryIndexOf = new Int32Array(tree.nodeCount).fill(-1);
|
|
2526
|
-
const entryNodes = [];
|
|
2527
|
-
for (let node = 0; node < tree.nodeCount; node++) {
|
|
2528
|
-
if (tree.kind[node] !== NodeKind.Chance) continue;
|
|
2529
|
-
if (tree.round[node] + 1 !== round) continue;
|
|
2530
|
-
entryIndexOf[node] = entryNodes.length;
|
|
2531
|
-
entryNodes.push(node);
|
|
2532
|
-
}
|
|
2533
|
-
if (entryNodes.length === 0) return null;
|
|
2534
|
-
const bounds = new Int32Array(workers + 1);
|
|
2535
|
-
for (let w = 0; w <= workers; w++) bounds[w] = Math.round(boards * w / workers);
|
|
2536
|
-
return { round, boards, entryNodes: Int32Array.from(entryNodes), entryIndexOf, bounds };
|
|
2537
|
-
}
|
|
2538
|
-
function startPool(ctx, solver, plan, payload, workers) {
|
|
2539
|
-
const entryCount = plan.entryNodes.length;
|
|
2540
|
-
const spawned = workers - 1;
|
|
2541
|
-
const reachFloats = entryCount * 2 * COMBOS;
|
|
2542
|
-
const partialFloats = spawned * entryCount * COMBOS;
|
|
2543
|
-
const exchangeBuffer = new SharedArrayBuffer((reachFloats + partialFloats) * 8);
|
|
2544
|
-
const exchange = new Float64Array(exchangeBuffer);
|
|
2545
|
-
const controlBuffer = new SharedArrayBuffer(CONTROL.size * 4);
|
|
2546
|
-
const control = new Int32Array(controlBuffer);
|
|
2547
|
-
const threads = [];
|
|
2548
|
-
let failure = null;
|
|
2549
|
-
for (let w = 0; w < spawned; w++) {
|
|
2550
|
-
const setup = {
|
|
2551
|
-
workerId: w,
|
|
2552
|
-
payload,
|
|
2553
|
-
plan: { round: plan.round, entryNodes: plan.entryNodes, entryIndexOf: plan.entryIndexOf },
|
|
2554
|
-
shardStart: plan.bounds[w + 1],
|
|
2555
|
-
shardEnd: plan.bounds[w + 2],
|
|
2556
|
-
regret: ctx.regret.buffer,
|
|
2557
|
-
strategySum: ctx.strategySum.buffer,
|
|
2558
|
-
regretScale: ctx.regretScale?.buffer ?? null,
|
|
2559
|
-
sumScale: ctx.sumScale?.buffer ?? null,
|
|
2560
|
-
control: controlBuffer,
|
|
2561
|
-
exchange: exchangeBuffer,
|
|
2562
|
-
entryCount
|
|
2563
|
-
};
|
|
2564
|
-
const thread = spawnWorker(setup, (error) => {
|
|
2565
|
-
failure ??= error;
|
|
2566
|
-
Atomics.store(control, CONTROL.ready, spawned);
|
|
2567
|
-
Atomics.add(control, CONTROL.done, spawned);
|
|
2568
|
-
Atomics.notify(control, CONTROL.done);
|
|
2569
|
-
Atomics.notify(control, CONTROL.ready);
|
|
2570
|
-
});
|
|
2571
|
-
threads.push(thread);
|
|
2572
|
-
}
|
|
2573
|
-
for (; ; ) {
|
|
2574
|
-
const ready = Atomics.load(control, CONTROL.ready);
|
|
2575
|
-
if (ready >= spawned || failure) break;
|
|
2576
|
-
Atomics.wait(control, CONTROL.ready, ready, 20);
|
|
2577
|
-
}
|
|
2578
|
-
if (failure) {
|
|
2579
|
-
for (const thread of threads) thread.terminate();
|
|
2580
|
-
throw failure;
|
|
2581
|
-
}
|
|
2582
|
-
const total = new Float64Array(COMBOS);
|
|
2583
|
-
const chanceValues = new Float64Array(entryCount * COMBOS);
|
|
2584
|
-
const mainReachMe = new Float64Array(COMBOS);
|
|
2585
|
-
const mainReachOpp = new Float64Array(COMBOS);
|
|
2586
|
-
const dispatch = (mode, traverser, iterWeight) => {
|
|
2587
|
-
Atomics.store(control, CONTROL.done, 0);
|
|
2588
|
-
Atomics.store(control, CONTROL.mode, mode);
|
|
2589
|
-
Atomics.store(control, CONTROL.traverser, traverser);
|
|
2590
|
-
Atomics.store(control, CONTROL.iterWeight, iterWeight);
|
|
2591
|
-
Atomics.store(control, CONTROL.command, COMMAND.work);
|
|
2592
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2593
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2594
|
-
const fullStart = ctx.shardStart;
|
|
2595
|
-
const fullEnd = ctx.shardEnd;
|
|
2596
|
-
ctx.shardStart = plan.bounds[0];
|
|
2597
|
-
ctx.shardEnd = plan.bounds[1];
|
|
2598
|
-
ctx.applyUpdates = true;
|
|
2599
|
-
try {
|
|
2600
|
-
for (let entry = 0; entry < entryCount; entry++) {
|
|
2601
|
-
for (let i = 0; i < COMBOS; i++) {
|
|
2602
|
-
mainReachMe[i] = exchange[entry * 2 * COMBOS + i];
|
|
2603
|
-
mainReachOpp[i] = exchange[entry * 2 * COMBOS + COMBOS + i];
|
|
2604
|
-
}
|
|
2605
|
-
const value = solver.traverseChance(
|
|
2606
|
-
mode,
|
|
2607
|
-
traverser,
|
|
2608
|
-
iterWeight,
|
|
2609
|
-
plan.entryNodes[entry],
|
|
2610
|
-
mainReachMe,
|
|
2611
|
-
mainReachOpp
|
|
2612
|
-
);
|
|
2613
|
-
chanceValues.set(value.subarray(0, COMBOS), entry * COMBOS);
|
|
2614
|
-
}
|
|
2615
|
-
} finally {
|
|
2616
|
-
ctx.shardStart = fullStart;
|
|
2617
|
-
ctx.shardEnd = fullEnd;
|
|
2618
|
-
}
|
|
2619
|
-
for (; ; ) {
|
|
2620
|
-
const done = Atomics.load(control, CONTROL.done);
|
|
2621
|
-
if (done >= spawned) break;
|
|
2622
|
-
if (failure) throw failure;
|
|
2623
|
-
Atomics.wait(control, CONTROL.done, done, 50);
|
|
2624
|
-
}
|
|
2625
|
-
if (failure) throw failure;
|
|
2626
|
-
};
|
|
2627
|
-
return {
|
|
2628
|
-
workers,
|
|
2629
|
-
traverse(mode, traverser, iterWeight) {
|
|
2630
|
-
ctx.applyUpdates = false;
|
|
2631
|
-
ctx.chanceOverride = null;
|
|
2632
|
-
ctx.chanceCollect = (node, reachMe, reachOpp) => {
|
|
2633
|
-
const entry = plan.entryIndexOf[node];
|
|
2634
|
-
exchange.set(reachMe.subarray(0, COMBOS), entry * 2 * COMBOS);
|
|
2635
|
-
exchange.set(reachOpp.subarray(0, COMBOS), entry * 2 * COMBOS + COMBOS);
|
|
2636
|
-
};
|
|
2637
|
-
try {
|
|
2638
|
-
solver.traverseRoot(mode, traverser, iterWeight);
|
|
2639
|
-
} finally {
|
|
2640
|
-
ctx.chanceCollect = null;
|
|
2641
|
-
}
|
|
2642
|
-
dispatch(mode, traverser, iterWeight);
|
|
2643
|
-
for (let w = 0; w < spawned; w++) {
|
|
2644
|
-
const base = reachFloats + w * entryCount * COMBOS;
|
|
2645
|
-
for (let i = 0; i < entryCount * COMBOS; i++) chanceValues[i] += exchange[base + i];
|
|
2646
|
-
}
|
|
2647
|
-
ctx.chanceOverride = chanceValues;
|
|
2648
|
-
ctx.applyUpdates = true;
|
|
2649
|
-
try {
|
|
2650
|
-
const value = solver.traverseRoot(mode, traverser, iterWeight);
|
|
2651
|
-
total.set(value.subarray(0, COMBOS));
|
|
2652
|
-
} finally {
|
|
2653
|
-
ctx.chanceOverride = null;
|
|
2654
|
-
}
|
|
2655
|
-
return total;
|
|
2656
|
-
},
|
|
2657
|
-
close() {
|
|
2658
|
-
Atomics.store(control, CONTROL.command, COMMAND.exit);
|
|
2659
|
-
Atomics.add(control, CONTROL.generation, 1);
|
|
2660
|
-
Atomics.notify(control, CONTROL.generation);
|
|
2661
|
-
for (const thread of threads) thread.terminate();
|
|
2662
|
-
}
|
|
2663
|
-
};
|
|
2664
|
-
}
|
|
2665
|
-
|
|
2666
2696
|
// src/index.ts
|
|
2667
2697
|
var DEFAULT_CHIP_SCALE = 100;
|
|
2668
2698
|
var OPS_PER_SECOND = 2e8;
|
|
@@ -2700,12 +2730,16 @@ function defineSpot(config) {
|
|
|
2700
2730
|
const rounds = 6 - board.length;
|
|
2701
2731
|
if (config.pot <= 0) throw new Error("pot must be positive");
|
|
2702
2732
|
if (config.stack <= 0) throw new Error("stack must be positive");
|
|
2703
|
-
const
|
|
2704
|
-
|
|
2705
|
-
|
|
2706
|
-
|
|
2707
|
-
|
|
2708
|
-
|
|
2733
|
+
const rowsFor = (sizes, who) => {
|
|
2734
|
+
const expanded = sizes.length === 1 ? Array.from({ length: rounds }, () => sizes[0]) : sizes;
|
|
2735
|
+
if (expanded.length !== rounds) {
|
|
2736
|
+
throw new Error(
|
|
2737
|
+
`${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`
|
|
2738
|
+
);
|
|
2739
|
+
}
|
|
2740
|
+
return expanded;
|
|
2741
|
+
};
|
|
2742
|
+
const rows = isPerPlayer(config.betSizes) ? { oop: rowsFor(config.betSizes.oop, "oop "), ip: rowsFor(config.betSizes.ip, "ip ") } : rowsFor(config.betSizes, "");
|
|
2709
2743
|
const onBoard = new Set(board);
|
|
2710
2744
|
const trim = (range, who) => {
|
|
2711
2745
|
const weights = typeof range === "string" ? parseRange(range) : Float64Array.from(range);
|
|
@@ -2763,9 +2797,10 @@ function defineSpot(config) {
|
|
|
2763
2797
|
const compressedBytes = buildLayout(tree, runouts, players, 2).bytes + showdownBytes;
|
|
2764
2798
|
const suggestions = [];
|
|
2765
2799
|
if (compressedBytes > maxBytes) {
|
|
2766
|
-
const widest = Math.max(...rows.map((r) => r.length));
|
|
2800
|
+
const widest = Math.max(...[0, 1].flatMap((p) => forPlayer(rows, p).map((r) => r.length)));
|
|
2767
2801
|
if (widest > 1) suggestions.push(`use fewer bet sizes (currently up to ${widest} per round)`);
|
|
2768
|
-
|
|
2802
|
+
const raises = [0, 1].flatMap((p) => [forPlayer(config.maxRaises ?? 1, p)].flat());
|
|
2803
|
+
if (Math.max(...raises) > 1) suggestions.push(`lower maxRaises to 1`);
|
|
2769
2804
|
suggestions.push(`narrow the ranges (currently ${players[0].count} and ${players[1].count} combos)`);
|
|
2770
2805
|
if (runouts.rounds === 3) suggestions.push("solve from the turn instead of the flop");
|
|
2771
2806
|
}
|
|
@@ -3113,8 +3148,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
|
|
|
3113
3148
|
const invested = (tree.pot[node] - spot.potUnits) / 2;
|
|
3114
3149
|
const { source } = spot;
|
|
3115
3150
|
const later = (value, listed) => listed && value.length > 1 ? value.slice(round) : value;
|
|
3116
|
-
const
|
|
3117
|
-
const
|
|
3151
|
+
const laterEach = (value, listed) => value === void 0 ? void 0 : mapPlayers(value, (side) => later(side, listed(side)));
|
|
3152
|
+
const rows = laterEach(source.betSizes, () => true);
|
|
3153
|
+
const raiseRows = laterEach(source.raiseSizes, (side) => side !== void 0 && raisesPerRound(side));
|
|
3118
3154
|
return {
|
|
3119
3155
|
board: formatCards(cards),
|
|
3120
3156
|
pot: tree.pot[node] / spot.chipScale,
|
|
@@ -3123,9 +3159,9 @@ function makeSolution(spot, ctx, solver, iterations, totalIterations, history, s
|
|
|
3123
3159
|
ip: reachAt(node, board, 1),
|
|
3124
3160
|
betSizes: betting.betSizes ?? rows,
|
|
3125
3161
|
raiseSizes: "raiseSizes" in betting ? betting.raiseSizes : raiseRows,
|
|
3126
|
-
maxRaises: betting.maxRaises ?? (source.maxRaises
|
|
3127
|
-
allowAllIn: betting.allowAllIn ?? (source.allowAllIn
|
|
3128
|
-
allInThreshold: "allInThreshold" in betting ? betting.allInThreshold :
|
|
3162
|
+
maxRaises: betting.maxRaises ?? laterEach(source.maxRaises, Array.isArray),
|
|
3163
|
+
allowAllIn: betting.allowAllIn ?? laterEach(source.allowAllIn, Array.isArray),
|
|
3164
|
+
allInThreshold: "allInThreshold" in betting ? betting.allInThreshold : laterEach(source.allInThreshold, Array.isArray),
|
|
3129
3165
|
noDonk: "noDonk" in betting ? betting.noDonk : source.noDonk === void 0 ? void 0 : later(source.noDonk, Array.isArray(source.noDonk)),
|
|
3130
3166
|
mergeSizes: "mergeSizes" in betting ? betting.mergeSizes : source.mergeSizes,
|
|
3131
3167
|
minWeight: source.minWeight,
|