Strategy Script Reference

A strategy is a short JavaScript file. It registers handlers for things that happen at the table, and inside a handler it looks at the table and places bets. There is nothing else to it: no clock, no random numbers, no network. The same script dealt the same dice always plays the same way.

t.unit = 10;

on.comingOut(t => {
    if (!t.has('passline')) t.set('passline', t.unit);
});

on.pointPhase(t => {
    if (!t.has('passlineodds')) t.set('passlineodds', t.maxOdds('passline'));
});

The editor checks syntax as you type. Check and Save also play the script through a few thousand rolls and list anything it gets wrong, with the line. Click a problem to go to it. A script with a problem in it is not saved.

Events: on

Each takes a function. The function is given the table, t, and, if it asks for a second argument, the event, e. Handlers for the same event run in the order they were registered. Your favorite bets are put back up before any of them.

The event, e

The table: t

Placing and moving bets

The table's rules still apply. A bet that is not allowed right now, or that you cannot afford, is not placed; an amount is rounded to a proper multiple where the bet needs one; odds are capped at the table's maximum.

Amounts

Looking at the table

Bet names

Lowercase, no spaces. A name the table does not know is reported as a problem, with its line. The common ones are below; Appendix A lists every bet and Appendix B every spread.

When the number is not known until the moment, build the name: t.set(`come${e.point}odds`, t.maxOdds(`come${e.point}`));

Examples

3-Point Molly

t.unit = 10;

on.comingOut(t => {
    if (!t.has('passline')) t.set('passline', t.unit);
});

on.pointPhase(t => {
    if (t.has('passline') && !t.has('passlineodds')) t.set('passlineodds', t.maxOdds('passline'));
    if (t.comeCount < 2) t.set('come', t.unit);
});

on.comeTravels((t, e) => {
    t.set(`come${e.point}odds`, t.maxOdds(`come${e.point}`));
});

Press the 6 and 8 every second hit

A script can keep count of things for itself. Its variables start over when the strategy is activated.

let hits = 0;

on.pointPhase(t => {
    if (!t.has('place6')) t.set('place6', 12);
    if (!t.has('place8')) t.set('place8', 12);
});

on.win(['place6', 'place8'], (t, e) => {
    hits++;
    if (hits % 2 === 0 && t.amount(e.key) < 60) t.press(e.key);
});

on.sevenOut(() => { hits = 0; });

Double the unit after a loss, up to a limit

const base = 10;
t.unit = base;

on.comingOut(t => {
    if (!t.has('passline')) t.set('passline', t.unit);
});

on.lose('passline', t => { t.unit = Math.min(t.unit * 2, 80); });
on.win('passline', t => { t.unit = base; });

Writing your own functions

A script is ordinary JavaScript, so whatever the table does not give you, you can write: a function, a list, a running count, a class. t and on are available everywhere in the script, so a helper at the top can read the table without being handed it.

A total the table does not have

const inside = ['place5', 'place6', 'place8', 'place9'];

// Dollars on a list of bets
const total = bets => bets.reduce((sum, bet) => sum + t.amount(bet), 0);

on.pointPhase(t => {
    if (total(inside) < 100) t.spread('inside', 44);
});

A helper you call from several handlers

function keep(bet, dollars) {
    if (!t.has(bet)) t.set(bet, dollars);
}

on.pointPhase(() => {
    keep('place6', 12);
    keep('place8', 12);
});

on.pointHits(() => keep('field', 5));

A progression that remembers where it is

const steps = [12, 18, 30, 60];
let rung = 0;
const hitsByBet = new Map();

on.pointPhase(t => {
    const dollars = steps[Math.min(rung, steps.length - 1)];
    if (!t.has('place6')) t.set('place6', dollars);
    if (!t.has('place8')) t.set('place8', dollars);
});

on.win(['place6', 'place8'], (t, e) => {
    hitsByBet.set(e.key, (hitsByBet.get(e.key) || 0) + 1);
    const hits = [...hitsByBet.values()].reduce((a, b) => a + b, 0);
    if (hits % 3 === 0) rung++;
});

on.sevenOut(() => { rung = 0; hitsByBet.clear(); });

Things to know

• What a script remembers lasts as long as the strategy is active. Its variables start over each time the strategy is activated, and at the start of every simulated session. Nothing a script keeps survives closing the app. The table's own counts (t.winCount, t.rollCount, and the rest) are kept by the table, not the script.
• A misspelled bet inside your own function is found later. The editor reads bet names straight out of calls on the table, like t.set('place6', 12), and reports every wrong one at once. A name handed to your own function, like keep('palce6', 12), is only found when Check plays the script and the dice reach that line.
• The names t and on are taken. A script that declares its own t or on at the top will not load.
• One strategy cannot use another's functions. There is no import; copy a helper into each strategy that needs it.

Limits

• One handler call may run 50,000 statements and nest 64 calls deep. Looping over every bet on the table is nowhere near that; it exists to stop a loop that never ends.
• A handler that runs away (an endless loop) is stopped and reported as a problem.
• Math.random and Date are not available. A strategy reacts to the table and nothing else, which is what lets the simulator repeat a run exactly.
• If a handler throws while you are playing, the table shows the line and the message once, and carries on; the rest of the script keeps running.

Appendix A: every bet

These are the names t.set, t.bet, t.has, t.amount, on.win and the rest understand. They are lowercase with no spaces. Any other name is reported as a problem, with its line.

The table's rules decide whether a bet goes down, whatever the script asks for: a Pass Line bet is not taken once a point is on, odds need their flat bet, an amount is rounded to a proper multiple, and a bet you cannot afford is skipped.

Appendix B: every spread

A spread is a dealer's call: one amount, shared over several bets in proper multiples. Use these names with t.spread(name, dollars) and t.spreadUnits(name, n), never with t.set. What goes down are the bets in the right-hand column, and those are the names to use with t.has, t.amount and on.win.

on.newPoint(t => t.spread('across', 64));

on.win(['place6', 'place8'], (t, e) => t.press(e.key));

The horn and combination props in Appendix A (horn, comboworld, comboce and the rest) can also be given to t.spread, which sizes them in proper multiples.