From 04b943677dabb4001fafb98f5da24e50e361d261 Mon Sep 17 00:00:00 2001 From: Tom Hummel Date: Sat, 14 Jun 2025 07:52:52 -0700 Subject: [PATCH 1/2] Fix odds amount for point five --- README.md | 8 +++ betting.js | 24 ++++++- betting.test.js | 54 ++++++++++++++++ index.test.js | 40 ++++++++++++ settle.js | 103 ++++++++++++++++++++++++++--- settle.test.js | 168 ++++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 386 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 95f6370..9766ac3 100644 --- a/README.md +++ b/README.md @@ -65,6 +65,14 @@ Hand: 1 └─────────┴──────┴──────┴─────────┴─────────────┴───────────┴───────┘ ``` +## strategies + +The `betting` module exposes a few simple strategy helpers: + +- `minPassLineOnly` – always maintains a minimum pass line bet +- `minPassLineMaxOdds` – adds maximum odds on the pass line point +- `minComeLineMaxOdds` – once a point is set, places come bets with max odds + ## what? why? I like to play craps sometimes. I have a handful of strategies I like to play. It is time consuming to play in an app. I'd like to play 5, 50, 500 hands very fast using various strategies. Which strategies are best is well understood, the variability comes in with how aggressive your strategies are and the level of risk you assume at any given moment. And of course the dice outcomes and their deviation from long term probabilities and how they interact with the strategies you employ is the fun part. This simulator lets me scratch my craps itch very quickly. diff --git a/betting.js b/betting.js index 47623f4..6c9cedc 100644 --- a/betting.js +++ b/betting.js @@ -35,7 +35,29 @@ function minPassLineMaxOdds (opts) { return bets } +function minComeLineMaxOdds (opts) { + const { rules, hand } = opts + const bets = minPassLineMaxOdds(opts) + + if (!hand.isComeOut && !bets?.come?.line) { + bets.come = { + line: { amount: rules.minBet }, + isComeOut: true + } + bets.new += rules.minBet + } + + if (bets?.come?.line && !bets.come.isComeOut && !bets.come.odds) { + const oddsAmount = rules.maxOddsMultiple[bets.come.point] * bets.come.line.amount + bets.come.odds = { amount: oddsAmount } + bets.new += oddsAmount + } + + return bets +} + module.exports = { minPassLineOnly, - minPassLineMaxOdds + minPassLineMaxOdds, + minComeLineMaxOdds } diff --git a/betting.test.js b/betting.test.js index 1387e26..2171f14 100644 --- a/betting.test.js +++ b/betting.test.js @@ -209,3 +209,57 @@ tap.test('minPassLineMaxOdds: continue existing bet', (t) => { t.end() }) + +tap.test('minComeLineMaxOdds: place come bet after point set', (t) => { + const rules = { + minBet: 5, + maxOddsMultiple: { + 4: 3, + 5: 4, + 6: 5, + 8: 5, + 9: 4, + 10: 3 + } + } + + const hand = { isComeOut: false, point: 5 } + const bets = { + pass: { line: { amount: 5, isContract: true }, odds: { amount: 20 } }, + new: 0 + } + + const updatedBets = lib.minComeLineMaxOdds({ rules, bets, hand }) + t.equal(updatedBets.come.line.amount, rules.minBet) + t.ok(updatedBets.come.isComeOut) + t.equal(updatedBets.new, rules.minBet) + + t.end() +}) + +tap.test('minComeLineMaxOdds: add odds after come point', (t) => { + const rules = { + minBet: 5, + maxOddsMultiple: { + 4: 3, + 5: 4, + 6: 5, + 8: 5, + 9: 4, + 10: 3 + } + } + + const hand = { isComeOut: false, point: 5 } + const bets = { + pass: { line: { amount: 5, isContract: true }, odds: { amount: 20 } }, + come: { line: { amount: 5 }, isComeOut: false, point: 4 }, + new: 0 + } + + const updatedBets = lib.minComeLineMaxOdds({ rules, bets, hand }) + t.equal(updatedBets.come.odds.amount, rules.maxOddsMultiple['4'] * 5) + t.equal(updatedBets.new, rules.maxOddsMultiple['4'] * 5) + + t.end() +}) diff --git a/index.test.js b/index.test.js index ea3e556..df5c940 100644 --- a/index.test.js +++ b/index.test.js @@ -479,3 +479,43 @@ tap.test('integration: minPassLineMaxOdds, one hand with everything', (suite) => suite.end() }) + +tap.test('integration: minComeLineMaxOdds, one hand with come bets', (suite) => { + let rollCount = -1 + const fixedRolls = [ + 4, 3, // comeout win + 5, 6, // comeout win + 2, 2, // comeout loss + 3, 3, // point set + 5, 4, // come bet sets point + 5, 4, // come bet point win + 3, 4 // seven out + ] + + function testRoll () { + rollCount++ + if (!fixedRolls[rollCount]) { + console.log('falsy return from fixed dice') + process.exit(1) + } + return fixedRolls[rollCount] + } + + const rules = { + minBet: 5, + maxOddsMultiple: { + 4: 3, + 5: 4, + 6: 5, + 8: 5, + 9: 4, + 10: 3 + } + } + + const hand = lib.playHand({ rules, roll: testRoll, bettingStrategy: betting.minComeLineMaxOdds }) + suite.ok(Array.isArray(hand.history)) + suite.type(hand.balance, 'number') + + suite.end() +}) diff --git a/settle.js b/settle.js index 7af2783..7525338 100644 --- a/settle.js +++ b/settle.js @@ -19,6 +19,15 @@ function passLine ({ bets, hand, rules }) { return { payout, bets } } +const oddsPayouts = { + 4: 2, + 5: 3 / 2, + 6: 6 / 5, + 8: 6 / 5, + 9: 3 / 2, + 10: 2 +} + function passOdds ({ bets, hand, rules }) { if (!bets?.pass?.odds) return { bets } @@ -27,19 +36,10 @@ function passOdds ({ bets, hand, rules }) { if (!betHasAction) return { bets } // keep bets intact if no action - const payouts = { - 4: 2, - 5: 3 / 2, - 6: 6 / 5, - 8: 6 / 5, - 9: 3 / 2, - 10: 2 - } - const payout = { type: 'pass odds win', principal: bets.pass.odds.amount, - profit: bets.pass.odds.amount * payouts[hand.diceSum] + profit: bets.pass.odds.amount * oddsPayouts[hand.diceSum] } delete bets.pass.odds // clear pass odds bet on action @@ -49,6 +49,78 @@ function passOdds ({ bets, hand, rules }) { return { payout, bets } } +function comeLine ({ bets, hand, rules }) { + if (!bets?.come?.line) return { bets } + + const bet = bets.come + let payout + + if (bet.isComeOut) { + if ([2, 3, 12].includes(hand.diceSum)) { + delete bets.come + return { bets } + } + if ([7, 11].includes(hand.diceSum)) { + payout = { + type: 'come win', + principal: bet.line.amount, + profit: bet.line.amount * 1 + } + delete bets.come + return { payout, bets } + } + + bet.point = hand.diceSum + bet.isComeOut = false + bet.line.isContract = true + return { bets } + } + + if (hand.diceSum === bet.point) { + payout = { + type: 'come win', + principal: bet.line.amount, + profit: bet.line.amount * 1 + } + delete bet.line + if (!bet.odds) delete bets.come + return { payout, bets } + } + + if (hand.diceSum === 7) { + delete bet.line + if (!bet.odds) delete bets.come + return { bets } + } + + return { bets } +} + +function comeOdds ({ bets, hand, rules }) { + if (!bets?.come?.odds) return { bets } + + const bet = bets.come + + if (hand.diceSum === bet.point) { + const payout = { + type: 'come odds win', + principal: bet.odds.amount, + profit: bet.odds.amount * oddsPayouts[bet.point] + } + delete bet.odds + if (!bet.line) delete bets.come + return { payout, bets } + } + + if (hand.diceSum === 7) { + delete bet.odds + if (!bet.line) delete bets.come + return { bets } + } + + return { bets } +} + function all ({ bets, hand, rules }) { const payouts = [] @@ -62,6 +134,15 @@ function all ({ bets, hand, rules }) { bets = passOddsResult.bets payouts.push(passOddsResult.payout) + const comeLineResult = comeLine({ bets, hand, rules }) + bets = comeLineResult.bets + payouts.push(comeLineResult.payout) + + const comeOddsResult = comeOdds({ bets, hand, rules }) + + bets = comeOddsResult.bets + payouts.push(comeOddsResult.payout) + bets.payouts = payouts.reduce((memo, payout) => { if (!payout) return memo @@ -83,5 +164,7 @@ function all ({ bets, hand, rules }) { module.exports = { passLine, passOdds, + comeLine, + comeOdds, all } diff --git a/settle.test.js b/settle.test.js index 0e542d7..1cea4b8 100644 --- a/settle.test.js +++ b/settle.test.js @@ -357,6 +357,174 @@ tap.test('passOdds: odds bet, seven out', function (t) { t.end() }) +tap.test('comeLine: come win on 7', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: true + } + } + + const hand = { diceSum: 7 } + + const result = settle.comeLine({ hand, bets }) + t.equal(result.payout.type, 'come win') + t.equal(result.payout.principal, 5) + t.equal(result.payout.profit, 5) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeLine: craps 2', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: true + } + } + + const hand = { diceSum: 2 } + + const result = settle.comeLine({ hand, bets }) + t.notOk(result.payout) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeLine: craps 3', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: true + } + } + + const hand = { diceSum: 3 } + + const result = settle.comeLine({ hand, bets }) + t.notOk(result.payout) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeLine: craps 12', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: true + } + } + + const hand = { diceSum: 12 } + + const result = settle.comeLine({ hand, bets }) + t.notOk(result.payout) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeLine: come win on 11', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: true + } + } + + const hand = { diceSum: 11 } + + const result = settle.comeLine({ hand, bets }) + t.equal(result.payout.type, 'come win') + t.equal(result.payout.principal, 5) + t.equal(result.payout.profit, 5) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeLine: point win', function (t) { + const bets = { + come: { + line: { amount: 5 }, + isComeOut: false, + point: 6 + } + } + + const hand = { diceSum: 6 } + + const result = settle.comeLine({ hand, bets }) + t.equal(result.payout.type, 'come win') + t.equal(result.payout.principal, 5) + t.equal(result.payout.profit, 5) + t.notOk(result.bets.come) + + t.end() +}) + +tap.test('comeOdds: odds bet, win', function (t) { + const bets = { + come: { + line: { amount: 5 }, + odds: { amount: 10 }, + isComeOut: false, + point: 4 + } + } + + const hand = { diceSum: 4 } + + const result = settle.comeOdds({ hand, bets }) + t.equal(result.payout.type, 'come odds win') + t.equal(result.payout.principal, 10) + t.equal(result.payout.profit, 20) + t.notOk(result.bets.come.odds) + + t.end() +}) + +tap.test('comeOdds: odds bet, seven out', function (t) { + const bets = { + come: { + line: { amount: 5 }, + odds: { amount: 10 }, + isComeOut: false, + point: 4 + } + } + + const hand = { diceSum: 7 } + + const result = settle.comeOdds({ hand, bets }) + t.notOk(result.payout) + t.notOk(result.bets.come.odds) + + t.end() +}) + +tap.test('comeOdds: odds bet, no action', function (t) { + const bets = { + come: { + line: { amount: 5 }, + odds: { amount: 10 }, + isComeOut: false, + point: 4 + } + } + + const hand = { diceSum: 5 } + + const result = settle.comeOdds({ hand, bets }) + t.notOk(result.payout) + t.strictSame(result.bets, bets, 'bets unchanged') + + t.end() +}) + tap.test('all: pass line win', (t) => { const bets = { pass: { From d0dbe73bd33aa95c4974c7df913ab51fc0d1da61 Mon Sep 17 00:00:00 2001 From: Tom Hummel Date: Sun, 15 Jun 2025 10:43:26 -0700 Subject: [PATCH 2/2] Merge main into work --- README.md | 23 ++++++++++ betting.js | 24 ++++++++++- betting.test.js | 67 +++++++++++++++++++++++++++++ hands.js | 6 +-- index.js | 18 +++++--- index.test.js | 21 +++++++++ settle.js | 46 ++++++++++++++++++++ settle.test.js | 111 ++++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 307 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 9766ac3..604ee11 100644 --- a/README.md +++ b/README.md @@ -73,6 +73,29 @@ The `betting` module exposes a few simple strategy helpers: - `minPassLineMaxOdds` – adds maximum odds on the pass line point - `minComeLineMaxOdds` – once a point is set, places come bets with max odds +## table rules + +`playHand` accepts a `rules` object that controls minimum bets and odds limits. +You can now also customize which numbers win or lose on the come out roll. + +```js +const rules = { + minBet: 5, + maxOddsMultiple: { /* ... */ }, + comeOutWin: [7, 11], + comeOutLoss: [2, 3, 12] // default +} +``` + +For example, to make boxcars (12) a come out win instead of a loss: + +```js +const rules = { + comeOutLoss: [2, 3], + comeOutWin: [7, 11, 12] +} +``` + ## what? why? I like to play craps sometimes. I have a handful of strategies I like to play. It is time consuming to play in an app. I'd like to play 5, 50, 500 hands very fast using various strategies. Which strategies are best is well understood, the variability comes in with how aggressive your strategies are and the level of risk you assume at any given moment. And of course the dice outcomes and their deviation from long term probabilities and how they interact with the strategies you employ is the fun part. This simulator lets me scratch my craps itch very quickly. diff --git a/betting.js b/betting.js index 6c9cedc..1238e61 100644 --- a/betting.js +++ b/betting.js @@ -56,8 +56,30 @@ function minComeLineMaxOdds (opts) { return bets } +function placeSixEight (opts) { + const { rules, bets: existingBets = {}, hand } = opts + const bets = Object.assign({ new: 0 }, existingBets) + + if (hand.isComeOut) return bets + + bets.place = bets.place || {} + + if (!bets.place.six) { + bets.place.six = { amount: rules.minBet } + bets.new += bets.place.six.amount + } + + if (!bets.place.eight) { + bets.place.eight = { amount: rules.minBet } + bets.new += bets.place.eight.amount + } + + return bets +} + module.exports = { minPassLineOnly, minPassLineMaxOdds, - minComeLineMaxOdds + minComeLineMaxOdds, + placeSixEight } diff --git a/betting.test.js b/betting.test.js index 2171f14..f0d6e58 100644 --- a/betting.test.js +++ b/betting.test.js @@ -233,6 +233,24 @@ tap.test('minComeLineMaxOdds: place come bet after point set', (t) => { t.equal(updatedBets.come.line.amount, rules.minBet) t.ok(updatedBets.come.isComeOut) t.equal(updatedBets.new, rules.minBet) + t.end() +}) + +tap.test('placeSixEight: make new place bets after point set', (t) => { + const rules = { + minBet: 6 + } + + const hand = { + isComeOut: false, + point: 5 + } + + const updatedBets = lib.placeSixEight({ rules, hand }) + + t.equal(updatedBets.place.six.amount, rules.minBet) + t.equal(updatedBets.place.eight.amount, rules.minBet) + t.equal(updatedBets.new, rules.minBet * 2) t.end() }) @@ -263,3 +281,52 @@ tap.test('minComeLineMaxOdds: add odds after come point', (t) => { t.end() }) + +tap.test('placeSixEight: no new bets on comeout', (t) => { + const rules = { minBet: 6 } + const hand = { isComeOut: true } + + const updatedBets = lib.placeSixEight({ rules, hand }) + + t.notOk(updatedBets.place) + t.notOk(updatedBets.new) + + t.end() +}) + +tap.test('placeSixEight: existing bets remain', (t) => { + const rules = { minBet: 6 } + const hand = { isComeOut: false, point: 8 } + + const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } } + + const updatedBets = lib.placeSixEight({ rules, bets, hand }) + + t.equal(updatedBets.place.six.amount, 6) + t.equal(updatedBets.place.eight.amount, 6) + t.notOk(updatedBets.new) + + t.end() +}) + +tap.test('placeSixEight: place bets even when point is 6 or 8', (t) => { + const rules = { minBet: 6 } + const handSix = { isComeOut: false, point: 6 } + + const firstBets = lib.placeSixEight({ rules, hand: handSix }) + + t.equal(firstBets.place.six.amount, rules.minBet) + t.equal(firstBets.place.eight.amount, rules.minBet) + t.equal(firstBets.new, rules.minBet * 2) + + delete firstBets.new + + const handEight = { isComeOut: false, point: 8 } + const bets = lib.placeSixEight({ rules, bets: firstBets, hand: handEight }) + + t.equal(bets.place.six.amount, rules.minBet) + t.equal(bets.place.eight.amount, rules.minBet) + t.notOk(bets.new) + + t.end() +}) diff --git a/hands.js b/hands.js index 7c56797..14adaf2 100644 --- a/hands.js +++ b/hands.js @@ -1,13 +1,13 @@ 'use strict' const { playHand } = require('./index.js') -const { minPassLineMaxOdds } = require('./betting.js') +const { placeSixEight } = require('./betting.js') const numHands = parseInt(process.argv.slice(2)[0], 10) const showDetail = process.argv.slice(2)[1] console.log(`Simulating ${numHands} Craps Hand(s)`) -console.log('Using betting strategy: minPassLineMaxOdds') +console.log('Using betting strategy: placeSixEight') const summaryTemplate = { balance: 0, @@ -51,7 +51,7 @@ const rules = { console.log(`[table rules] minimum bet: $${rules.minBet}`) for (let i = 0; i < numHands; i++) { - const hand = playHand({ rules, bettingStrategy: minPassLineMaxOdds }) + const hand = playHand({ rules, bettingStrategy: placeSixEight }) hand.summary = Object.assign({}, summaryTemplate) sessionSummary.balance += hand.balance diff --git a/index.js b/index.js index d52aeba..eb61ddf 100644 --- a/index.js +++ b/index.js @@ -7,7 +7,13 @@ function rollD6 () { return 1 + Math.floor(Math.random() * 6) } -function shoot (before, dice) { +const defaultRules = { + comeOutLoss: [2, 3, 12], + comeOutWin: [7, 11] +} + +function shoot (before, dice, rules = defaultRules) { + rules = Object.assign({}, defaultRules, rules) const sortedDice = dice.sort() const after = { @@ -19,10 +25,10 @@ function shoot (before, dice) { // game logic based on: https://github.com/tphummel/dice-collector/blob/master/PyTom/Dice/logic.py if (before.isComeOut) { - if ([2, 3, 12].indexOf(after.diceSum) !== -1) { + if (rules.comeOutLoss.includes(after.diceSum)) { after.result = 'comeout loss' after.isComeOut = true - } else if ([7, 11].indexOf(after.diceSum) !== -1) { + } else if (rules.comeOutWin.includes(after.diceSum)) { after.result = 'comeout win' after.isComeOut = true } else { @@ -65,7 +71,8 @@ function playHand ({ rules, bettingStrategy, roll = rollD6 }) { hand = shoot( hand, - [roll(), roll()] + [roll(), roll()], + rules ) if (process.env.DEBUG) console.log(`[roll] ${hand.result} (${hand.diceSum})`) @@ -88,5 +95,6 @@ module.exports = { rollD6, shoot, playHand, - betting + betting, + defaultRules } diff --git a/index.test.js b/index.test.js index df5c940..0210561 100644 --- a/index.test.js +++ b/index.test.js @@ -199,6 +199,27 @@ tap.test('comeout', function (suite) { suite.end() }) +tap.test('comeout with custom rules', (t) => { + const handState = { + isComeOut: true + } + + const rules = { + comeOutLoss: [2, 3], + comeOutWin: [7, 11, 12] + } + + const result = lib.shoot(handState, [6, 6], rules) + t.equal(result.result, 'comeout win') + t.notOk(result.point) + t.equal(result.die1, 6) + t.equal(result.die2, 6) + t.equal(result.diceSum, 12) + t.equal(result.isComeOut, true) + + t.end() +}) + tap.test('point set', (suite) => { suite.test('neutral 2', (t) => { const handState = { diff --git a/settle.js b/settle.js index 7525338..fdb67f6 100644 --- a/settle.js +++ b/settle.js @@ -121,6 +121,39 @@ function comeOdds ({ bets, hand, rules }) { return { bets } } +function placeBet ({ bets, hand, placeNumber }) { + const label = placeNumber === 6 ? 'six' : placeNumber === 8 ? 'eight' : String(placeNumber) + + if (!bets?.place?.[label]) return { bets } + if (hand.isComeOut && hand.result !== 'seven out') return { bets } + if (hand.result === 'point set') return { bets } + + if (hand.diceSum === 7) { + delete bets.place[label] + if (Object.keys(bets.place).length === 0) delete bets.place + return { bets } + } + + if (hand.diceSum === placeNumber) { + const payout = { + type: `place ${placeNumber} win`, + principal: 0, + profit: bets.place[label].amount * (7 / 6) + } + + return { payout, bets } + } + + return { bets } +} + +function placeSix (opts) { + return placeBet({ ...opts, placeNumber: 6 }) +} + +function placeEight (opts) { + return placeBet({ ...opts, placeNumber: 8 }) +} function all ({ bets, hand, rules }) { const payouts = [] @@ -143,6 +176,16 @@ function all ({ bets, hand, rules }) { bets = comeOddsResult.bets payouts.push(comeOddsResult.payout) + const placeSixResult = placeSix({ bets, hand }) + + bets = placeSixResult.bets + payouts.push(placeSixResult.payout) + + const placeEightResult = placeEight({ bets, hand }) + + bets = placeEightResult.bets + payouts.push(placeEightResult.payout) + bets.payouts = payouts.reduce((memo, payout) => { if (!payout) return memo @@ -166,5 +209,8 @@ module.exports = { passOdds, comeLine, comeOdds, + placeBet, + placeSix, + placeEight, all } diff --git a/settle.test.js b/settle.test.js index 1cea4b8..ff10626 100644 --- a/settle.test.js +++ b/settle.test.js @@ -553,3 +553,114 @@ tap.test('all: pass line win', (t) => { t.end() }) + +tap.test('placeSix: win', (t) => { + const bets = { place: { six: { amount: 6 } } } + + const hand = { + result: 'neutral', + isComeOut: false, + diceSum: 6 + } + + const result = settle.placeSix({ bets, hand }) + + t.equal(result.payout.type, 'place 6 win') + t.equal(result.payout.profit, 7) + t.equal(result.payout.principal, 0) + t.equal(result.bets.place.six.amount, 6) + + t.end() +}) + +tap.test('placeEight: win', (t) => { + const bets = { place: { eight: { amount: 6 } } } + + const hand = { + result: 'neutral', + isComeOut: false, + diceSum: 8 + } + + const result = settle.placeEight({ bets, hand }) + + t.equal(result.payout.type, 'place 8 win') + t.equal(result.payout.profit, 7) + t.equal(result.payout.principal, 0) + t.equal(result.bets.place.eight.amount, 6) + + t.end() +}) + +tap.test('place bets: seven out removes bets', (t) => { + const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } } + + const hand = { + result: 'seven out', + isComeOut: true, + diceSum: 7 + } + + const settled = settle.all({ bets, hand }) + + t.notOk(settled.place) + t.equal(settled.payouts.total, 0) + + t.end() +}) + +tap.test('place bets: no action on comeout roll', (t) => { + const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } } + + const hand = { + result: 'comeout win', + isComeOut: true, + diceSum: 7 + } + + const settled = settle.all({ bets, hand }) + + t.equal(settled.place.six.amount, 6) + t.equal(settled.place.eight.amount, 6) + t.equal(settled.payouts.total, 0) + + t.end() +}) + +tap.test('place bet on 6 persists when point is 6', (t) => { + const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } } + + const hand = { + result: 'point set', + isComeOut: false, + diceSum: 6, + point: 6 + } + + const settled = settle.all({ bets, hand }) + + t.equal(settled.place.six.amount, 6) + t.equal(settled.place.eight.amount, 6) + t.equal(settled.payouts.total, 0) + + t.end() +}) + +tap.test('place bet on 8 persists when point is 8', (t) => { + const bets = { place: { six: { amount: 6 }, eight: { amount: 6 } } } + + const hand = { + result: 'point set', + isComeOut: false, + diceSum: 8, + point: 8 + } + + const settled = settle.all({ bets, hand }) + + t.equal(settled.place.six.amount, 6) + t.equal(settled.place.eight.amount, 6) + t.equal(settled.payouts.total, 0) + + t.end() +})