23 |
24 |
25 |
26 |
78 |
79 |
89 |
--------------------------------------------------------------------------------
/src/core/combination-classes.js:
--------------------------------------------------------------------------------
1 | import { TileFactory } from './tile-classes'
2 |
3 | /**
4 | * Combination factory class
5 | * Factory design pattern to help create hand combination classes
6 | *
7 | * ex. : CombinationFactory.create('triplet', new DotTile(1))
8 | */
9 | export const CombinationFactory = {
10 | create (combinationType, firstCombinationTile) {
11 | switch (combinationType) {
12 | case 'pair':
13 | return new Pair(firstCombinationTile)
14 | case 'triplet':
15 | return new Triplet(firstCombinationTile)
16 | case 'quad':
17 | return new Quad(firstCombinationTile)
18 | case 'sequence': {
19 | const secondCombinationTile = TileFactory.create(firstCombinationTile.suit, firstCombinationTile.value + 1)
20 | const thirdCombinationTile = TileFactory.create(firstCombinationTile.suit, firstCombinationTile.value + 2)
21 | return new Sequence(firstCombinationTile, secondCombinationTile, thirdCombinationTile)
22 | }
23 | case 'orphan':
24 | return new Orphan(firstCombinationTile)
25 | default:
26 | throw new Error(`Hand Combination Factory Error: "${combinationType}" is not a supported combination type`)
27 | }
28 | }
29 | }
30 |
31 | /**
32 | * Combination base class (pair, triplet, quad, sequence)
33 | */
34 | export class Combination {
35 | constructor (tiles) {
36 | this.tiles = tiles // property that contain the tiles of the combination
37 | }
38 | }
39 |
40 | /**
41 | * Pair combination class
42 | * two identical tiles (ex. : 3,3 of bamboo tiles)
43 | *
44 | * param Tile tile
45 | */
46 | export class Pair extends Combination {
47 | constructor (tile) {
48 | super([
49 | TileFactory.create(tile.suit, tile.value),
50 | TileFactory.create(tile.suit, tile.value)
51 | ])
52 | }
53 | }
54 |
55 | /**
56 | * Triplet combination class
57 | * three identical tiles (ex. : 3,3,3 of bamboo tiles)
58 | *
59 | * param Tile tile
60 | */
61 | export class Triplet extends Combination {
62 | constructor (tile) {
63 | super([
64 | TileFactory.create(tile.suit, tile.value),
65 | TileFactory.create(tile.suit, tile.value),
66 | TileFactory.create(tile.suit, tile.value)
67 | ])
68 | }
69 | }
70 |
71 | /**
72 | * Quad combination class
73 | * four identical tiles (ex. : 3,3,3,3 of bamboo tiles)
74 | *
75 | * param Tile tile
76 | */
77 | export class Quad extends Combination {
78 | constructor (tile) {
79 | super([
80 | TileFactory.create(tile.suit, tile.value),
81 | TileFactory.create(tile.suit, tile.value),
82 | TileFactory.create(tile.suit, tile.value),
83 | TileFactory.create(tile.suit, tile.value)
84 | ])
85 | }
86 | }
87 |
88 | /**
89 | * Sequence combination class
90 | * three following numbered tile of the same suit (ex. : 2,3,4 of bamboo tiles)
91 | *
92 | * param Tile tile
93 | */
94 | export class Sequence extends Combination {
95 | constructor (tile1, tile2, tile3) {
96 | super([tile1, tile2, tile3])
97 | }
98 | }
99 |
100 | /**
101 | * Orphan combination class
102 | * one tile (only used for thirteen orphans yakuman)
103 | *
104 | * param Tile tile
105 | */
106 | export class Orphan extends Combination {
107 | constructor (tile) {
108 | super([tile])
109 | }
110 | }
111 |
--------------------------------------------------------------------------------
/src/core/ema/ema-fu-calculator.js:
--------------------------------------------------------------------------------
1 | import FuCalculator from '../fu-calculation/fu-calculator'
2 |
3 | import WinRule from '../fu-calculation/rules/winning-fu-rule'
4 | import WaitRule from '../fu-calculation/rules/wait-fu-rule'
5 | import TsumoRule from '../fu-calculation/rules/tsumo-fu-rule'
6 | import PairRule from '../fu-calculation/rules/pair-fu-rule'
7 | import OpenPinfuRule from '../fu-calculation/rules/open-pinfu-fu-rule'
8 | import CombinationsRule from '../fu-calculation/rules/combinations-fu-rule'
9 | import ClosedRonRule from '../fu-calculation/rules/closed-ron-fu-rule'
10 | import ChiitoitsuRule from '../fu-calculation/rules/chiitoitsu-fu-rule'
11 |
12 | import ChiitoitsuYaku from '../han-calculation/yakus/chiitoitsu-yaku'
13 | import PinfuYaku from '../han-calculation/yakus/pinfu-yaku'
14 |
15 | class EmaFuCalculator extends FuCalculator {
16 | constructor () {
17 | super([
18 | // put the chiitoitsu rule at the top because it's a fixed amount of fu
19 | new ChiitoitsuRule({ chiitoitsuYakuPattern: new ChiitoitsuYaku(), fuValue: 25 }),
20 | new WinRule(),
21 | new CombinationsRule(),
22 | new PairRule({ stackable: true }),
23 | new WaitRule(),
24 | new OpenPinfuRule(),
25 | new ClosedRonRule(),
26 | new TsumoRule({ excludedYakuPatterns: [new PinfuYaku()] })
27 | ])
28 | }
29 | }
30 |
31 | export default EmaFuCalculator
32 |
--------------------------------------------------------------------------------
/src/core/ema/ema-point-calculator.js:
--------------------------------------------------------------------------------
1 | import PointCalculator from '../point-calculation/point-calculator'
2 |
3 | class EmaPointCalculator extends PointCalculator {
4 | constructor () {
5 | super({
6 | kazoeYakumanAsSanbaiman: true,
7 | kiriageMangan: false
8 | })
9 | }
10 | }
11 |
12 | export default EmaPointCalculator
13 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/fu-calculation-context.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu calculation context information.
3 | *
4 | * @typedef {Object} FuCalculationContext
5 | * @property {boolean} stop=false - Flag indicating if the calculator can continue to process other rules
6 | * @property {boolean} rounding=true - Flag indicating if the calculator can round up to the tens the total
7 | * @memberof FuCalculation
8 | */
9 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/fu-calculation-result.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @typedef {Object} FuCalculationResult
3 | * @property {FuCalculation.FuInfo[]} details - Details explaining what are the fu sum in the total
4 | * @property {number} total - Total fu value of the hand. Usually round up to the tens (except in a few case like Chiitoitsu).
5 | * @memberof FuCalculation
6 | */
7 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/fu-calculator.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Base class for fu calculator implementations.
3 | * This class is intended to be used internally or to create custom fu calculator.
4 | *
5 | * Contains the logic to process a list of rules to aggregate a fu total
6 | * rounded up to the tens (except in a few case like Chiitoitsu).
7 | *
8 | * Real implementation, like WrcFuCalculator, would be better if you just want to get the fu value of a hand.
9 | *
10 | * @memberof FuCalculation
11 | */
12 | class FuCalculator {
13 | /**
14 | * @param {FuCalculation.FuRule[]} rules - Set of rules to check during the fu calculation process
15 | */
16 | constructor (rules) {
17 | if (rules == null) throw new Error('rules parameter is required')
18 |
19 | this.rules = rules
20 | }
21 |
22 | /**
23 | * Calculate the fu value of a hand.
24 | *
25 | * @param {Hand} hand
26 | * @returns {FuCalculation.FuCalculationResult}
27 | */
28 | calculate (hand) {
29 | const context = { stop: false, rounding: true }
30 | const details = []
31 |
32 | for (const rule of this.rules) {
33 | const result = rule.check(hand, context)
34 | if (result) details.push(...normalizeDetails(result))
35 | if (context.stop) break
36 | }
37 |
38 | let total = details.reduce((agg, x) => agg + (x.quantity * x.fuValue), 0)
39 |
40 | if (context.rounding) total = Math.ceil(total / 10) * 10
41 |
42 | return { details, total }
43 | }
44 | }
45 |
46 | function normalizeDetails (result) {
47 | return result instanceof Array ? result : [result]
48 | }
49 |
50 | export default FuCalculator
51 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/fu-info.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Information returned by fu calculation rule about why and how much fu the calculator need to add.
3 | *
4 | * @typedef {Object} FuInfo
5 | * @property {string} key - Key to identify why the fu are added
6 | * @property {number} fuValue - Amount of fu added
7 | * @property {number} quantity - Number of time those fu need to be added
8 | * @memberof FuCalculation
9 | */
10 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/fu-rule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu rule interface
3 | *
4 | * @interface FuRule
5 | * @memberof FuCalculation
6 | */
7 |
8 | /**
9 | * Function called by the fu calculator to know what fu are allowed according to this rule.
10 | *
11 | * @function
12 | * @name FuCalculation.FuRule#check
13 | * @param {Hand} hand - Hand to apply the rule onto
14 | * @param {FuCalculation.FuCalculationContext} context - Context of the fu calculation process
15 | * @returns {(undefined|FuCalculation.FuInfo|FuCalculation.FuInfo[])}
16 | */
17 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/index.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @namespace FuCalculation
3 | */
4 |
5 | export { default as ChiitoitsuFuRule } from './rules/chiitoitsu-fu-rule'
6 | export { default as ClosedRonFuRule } from './rules/closed-ron-fu-rule'
7 | export { default as CombinationsFuRule } from './rules/combinations-fu-rule'
8 | export { default as OpenPinfuFuRule } from './rules/open-pinfu-fu-rule'
9 | export { default as PairFuRule } from './rules/pair-fu-rule'
10 | export { default as TsumoFuRule } from './rules/tsumo-fu-rule'
11 | export { default as WaitFuRule } from './rules/wait-fu-rule'
12 | export { default as WinningFuRule } from './rules/winning-fu-rule'
13 |
14 | export { default as FuCalculator } from './fu-calculator'
15 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/chiitoitsu-fu-rule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu calculation rule that will attribute a fixed amount of fu (usually 25) for hands with chiitoitsu (seven pairs).
3 | *
4 | * As an exception, the fu value of the hand is not rounded up to the tens because it is worth of fixed amount.
5 | *
6 | * Some rules say seven pairs has 50 fu and one han, especially in the Kansai region.
7 | * https://en.wikipedia.org/wiki/Japanese_Mahjong_scoring_rules#Steps_of_calculation
8 | *
9 | * @implements FuCalculation.FuRule
10 | * @memberof FuCalculation
11 | */
12 | class ChiitoitsuFuRule {
13 | /**
14 | * @param {Object} options - Configuration options for the rule
15 | * @param {YakuPattern} options.chiitoitsuYakuPattern - Yaku pattern to validate the hand shape
16 | * @param {number} [options.fuValue=25] - Amount of fu to add if the rule is valid
17 | */
18 | constructor (options) {
19 | if (options?.chiitoitsuYakuPattern == null) throw new Error('chiitoitsuYakuPattern is required')
20 |
21 | this.chiitoitsuYakuPattern = options.chiitoitsuYakuPattern
22 | this.fuValue = options?.fuValue ?? 25
23 | }
24 |
25 | /** @override */
26 | check (hand, context) {
27 | if (this.chiitoitsuYakuPattern.check(hand)) {
28 | // tell the calculator to stop processing the other rules
29 | // and to not round up the total because this hand is always worth a fixed amount of fu.
30 | context.stop = true
31 | context.rounding = false
32 | return { key: 'chiitoitsu', fuValue: this.fuValue, quantity: 1 }
33 | }
34 | }
35 | }
36 |
37 | export default ChiitoitsuFuRule
38 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/closed-ron-fu-rule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu calculation rule that will attribute 10 fu for concealed hands won by ron.
3 | *
4 | * @implements FuCalculation.FuRule
5 | * @memberof FuCalculation
6 | */
7 | class ClosedRonFuRule {
8 | /** @override */
9 | check ({ isOpen, winningType }) {
10 | if (!isOpen && winningType === 'ron') {
11 | return { key: 'closed ron', fuValue: 10, quantity: 1 }
12 | }
13 | }
14 | }
15 |
16 | export default ClosedRonFuRule
17 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/combinations-fu-rule.js:
--------------------------------------------------------------------------------
1 | import { HonorTile } from './../../tile-classes'
2 | import { Triplet, Quad } from './../../combination-classes'
3 |
4 | /**
5 | * Fu calculation rule that will attribute fu according to the hand's combinations.
6 | *
7 | * If the hand's pair is of tiles that would score yakuhai in a koutsu, then this scores 2 fu.
8 | * If the pair doubles up as both the round wind and the seat wind, it may score 2 fu, or 4 fu.
9 | * That is dependent on which scoring rule is used for this case.
10 | * http://arcturus.su/wiki/Fu
11 | *
12 | * @implements FuCalculation.FuRule
13 | * @memberof FuCalculation
14 | */
15 | class PairFuRule {
16 | /**
17 | * @param {Object} options - Configuration options for the rule
18 | * @param {boolean} [options.stackable=true] - Flag indicating if we can stack the fu for the round wind and seat wind
19 | */
20 | constructor (options) {
21 | this.stackable = options?.stackable ?? true
22 | }
23 |
24 | /** @override */
25 | check ({ concealedCombinations, roundWind, seatWind }) {
26 | const pairs = concealedCombinations.filter(x => x instanceof Pair)
27 |
28 | if (pairs.length !== 1) return
29 |
30 | const tile = pairs[0].tiles[0]
31 |
32 | if (
33 | tile instanceof DragonTile ||
34 | tile.value === roundWind ||
35 | tile.value === seatWind
36 | ) {
37 | let quantity = 1
38 |
39 | if (this.stackable && tile.value === roundWind && tile.value === seatWind) {
40 | quantity++
41 | }
42 |
43 | return { key: 'pair', fuValue: 2, quantity }
44 | }
45 | }
46 | }
47 |
48 | export default PairFuRule
49 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/tsumo-fu-rule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu calculation rule that will attribute 2 fu if the hand was won by tsumo.
3 | *
4 | * Depending of the ruleset, some hands with certain yaku are not eligible. In most ruleset, this is the case for hands with a pinfu yaku.
5 | *
6 | * There is also some ruleset that exclude hands won with Rinshan Kaihou.
7 | *
8 | * @implements FuCalculation.FuRule
9 | * @memberof FuCalculation
10 | */
11 | class TsumoFuRule {
12 | /**
13 | * @param {Object} options - Configuration options for the rule
14 | * @param {YakuPattern[]} [options.excludedYakuPatterns=[]] - Yaku patterns excluded from getting the fu from this rule.
15 | * (usually Pinfu, but can also be Rinshan Kaihou)
16 | */
17 | constructor (options) {
18 | this.excludedYakuPatterns = options?.excludedYakuPatterns ?? []
19 | }
20 |
21 | /** @override */
22 | check (hand) {
23 | let excluded = false
24 |
25 | for (const yakuPattern of this.excludedYakuPatterns) {
26 | if (yakuPattern.check(hand)) {
27 | excluded = true
28 | break
29 | }
30 | }
31 |
32 | if (!excluded && hand.winningType === 'tsumo') {
33 | return { key: 'tsumo', fuValue: 2, quantity: 1 }
34 | }
35 | }
36 | }
37 |
38 | export default TsumoFuRule
39 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/wait-fu-rule.js:
--------------------------------------------------------------------------------
1 | import isTankiWait from './../../waits/is-tanki-wait'
2 | import isKanchanWait from './../../waits/is-kanchan-wait'
3 | import isPenchanWait from './../../waits/is-penchan-wait'
4 |
5 | /**
6 | * Fu calculation rule that will attribute fu according to the hand's wait.
7 | *
8 | * If the hand was waiting on only one tile, single wait (tanki), closed wait (kanchan) or edge wait (penchan), it is worth 2 fu.
9 | *
10 | * Other waits are worth nothing.
11 | *
12 | * @implements FuCalculation.FuRule
13 | * @memberof FuCalculation
14 | */
15 | class WaitFuRule {
16 | /** @override */
17 | check (hand) {
18 | if (isTankiWait(hand) || isKanchanWait(hand) || isPenchanWait(hand)) {
19 | return { key: 'wait', fuValue: 2, quantity: 1 }
20 | }
21 | }
22 | }
23 |
24 | export default WaitFuRule
25 |
--------------------------------------------------------------------------------
/src/core/fu-calculation/rules/winning-fu-rule.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Fu calculation rule that will attribute a default value of 20 fu for winning a hand.
3 | *
4 | * @implements FuCalculation.FuRule
5 | * @memberof FuCalculation
6 | */
7 | class WinningFuRule {
8 | /** @override */
9 | check () {
10 | return { key: 'win', fuValue: 20, quantity: 1 }
11 | }
12 | }
13 |
14 | export default WinningFuRule
15 |
--------------------------------------------------------------------------------
/src/core/han-calculation/han-calculation-result.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @typedef {Object} HanCalculationResult
3 | * @property {HanCalculation.HanInfo[]} details - Details explaining what are the han eligible for the hand
4 | * @property {number} han - Total han value of the hand. (null if it's a yakuman hand)
5 | * @property {number} yakuman - Total yakuman value of the hand. (null if it's not a yakuman hand)
6 | * @memberof HanCalculation
7 | */
8 |
--------------------------------------------------------------------------------
/src/core/han-calculation/han-calculator.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Base class for han calculator implementations.
3 | * This class is intended to be used internally or to create custom han calculator.
4 | *
5 | * Contains the logic to process a list of yaku to aggregate a han or yakuman total
6 | *
7 | * Real implementation, like WrcHanCalculator, would be better if you just want to get the han or yakuman value of a hand.
8 | *
9 | * @memberof HanCalculation
10 | */
11 | class HanCalculator {
12 | /**
13 | * @param {HanCalculation.Yaku[]} yakus - Set of yaku to check during the han calculation process
14 | */
15 | constructor (yakus, options) {
16 | if (yakus == null) throw new Error('yakus parameter is required')
17 |
18 | this.yakus = yakus
19 | this.stackableYakuman = options?.stackableYakuman ?? false
20 | }
21 |
22 | /**
23 | * Calculate the han value of a hand.
24 | *
25 | * @param {Hand} hand
26 | * @returns {HanCalculation.HanCalculationResult}
27 | */
28 | calculate (hand) {
29 | const details = []
30 |
31 | // process the hand for each yaku
32 |
33 | for (const yaku of this.yakus) {
34 | const result = yaku.check(hand)
35 | if (result) details.push(...normalizeDetails(result))
36 | }
37 |
38 | // sum the yakuman value of the hand and return early if it's higher than 0
39 | // because we don't need the han value if it's a yakuman hand
40 |
41 | const yakumanDetails = details.filter(x => x.yakumanValue != null && x.yakumanValue > 0)
42 |
43 | if (yakumanDetails.length > 0) {
44 | let yakuman = 0
45 |
46 | if (this.stackableYakuman) {
47 | yakuman = sum(yakumanDetails.map(x => x.yakumanValue))
48 | } else {
49 | // take the value of the yakuman with the highest value
50 | yakuman = Math.max(...yakumanDetails.map(x => x.yakumanValue))
51 | }
52 |
53 | return { details: details.filter(x => x.yakumanValue != null && x.yakumanValue > 0), han: null, yakuman }
54 | }
55 |
56 | // if it's not a yakuman hand
57 | // sum the han value of the hand
58 |
59 | let han = sum(details.map(x => x.hanValue))
60 |
61 | // add the number of dora to the han value of the hand only if the hand have
62 | // already some valid yaku
63 |
64 | if (han > 0 && hand.nbDora > 0) {
65 | han += hand.nbDora
66 | details.push({ key: 'dora', hanValue: hand.nbDora, yakumanValue: 0 })
67 | }
68 |
69 | return { details, han: han > 0 ? han : null, yakuman: null }
70 | }
71 | }
72 |
73 | function sum (array) {
74 | return array.reduce((agg, x) => {
75 | if (x != null) agg += x
76 | return agg
77 | }, 0)
78 | }
79 |
80 | function normalizeDetails (result) {
81 | return result instanceof Array ? result : [result]
82 | }
83 |
84 | export default HanCalculator
85 |
--------------------------------------------------------------------------------
/src/core/han-calculation/han-info.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Information returned by yaku about why and how much han or yakuman the calculator need to add.
3 | *
4 | * @typedef {Object} HanInfo
5 | * @property {string} key - Key to identify why the han are added
6 | * @property {number} hanValue - Amount of han added
7 | * @property {number} yakumanValue - Amount of yakuman added
8 | * @memberof HanCalculation
9 | */
10 |
--------------------------------------------------------------------------------
/src/core/han-calculation/index.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @namespace HanCalculation
3 | */
4 |
5 | export { default as ChankanYaku } from './yakus/chankan-yaku'
6 | export { default as ChantaYaku } from './yakus/chanta-yaku'
7 | export { default as ChiihouYaku } from './yakus/chiihou-yaku'
8 | export { default as ChiitoitsuYaku } from './yakus/chiitoitsu-yaku'
9 | export { default as ChinitsuYaku } from './yakus/chinitsu-yaku'
10 | export { default as ChinroutouYaku } from './yakus/chinroutou-yaku'
11 | export { default as ChuurenPoutouYaku } from './yakus/chuuren-poutou-yaku'
12 | export { default as DaisangenYaku } from './yakus/daisangen-yaku'
13 | export { default as DaisuushiiYaku } from './yakus/daisuushii-yaku'
14 | export { default as DoubleRiichiYaku } from './yakus/double-riichi-yaku'
15 | export { default as HaiteiRaoyueYaku } from './yakus/haitei-raoyue-yaku'
16 | export { default as HonitsuYaku } from './yakus/honitsu-yaku'
17 | export { default as HonroutouYaku } from './yakus/honroutou-yaku'
18 | export { default as HouteiRaoyuiYaku } from './yakus/houtei-raoyui-yaku'
19 | export { default as IipeikouYaku } from './yakus/iipeikou-yaku'
20 | export { default as IppatsuYaku } from './yakus/ippatsu-yaku'
21 | export { default as IttsuuYaku } from './yakus/ittsuu-yaku'
22 | export { default as JunchanYaku } from './yakus/junchan-yaku'
23 | export { default as KokushiMusouYaku } from './yakus/kokushi-musou-yaku'
24 | export { default as MenzenTsumoYaku } from './yakus/menzen-tsumo-yaku'
25 | export { default as OpenRiichiYaku } from './yakus/open-riichi-yaku'
26 | export { default as PinfuYaku } from './yakus/pinfu-yaku'
27 | export { default as RenhouYaku } from './yakus/renhou-yaku'
28 | export { default as RiichiYaku } from './yakus/riichi-yaku'
29 | export { default as RinshanKaihouYaku } from './yakus/rinshan-kaihou-yaku'
30 | export { default as RyanpeikouYaku } from './yakus/ryanpeikou-yaku'
31 | export { default as RyuuiisouYaku } from './yakus/ryuuiisou-yaku'
32 | export { default as SanankouYaku } from './yakus/sanankou-yaku'
33 | export { default as SankantsuYaku } from './yakus/sankantsu-yaku'
34 | export { default as SanshokuDoujunYaku } from './yakus/sanshoku-doujun-yaku'
35 | export { default as SanshokuDoukouYaku } from './yakus/sanshoku-doukou-yaku'
36 | export { default as ShousangenYaku } from './yakus/shousangen-yaku'
37 | export { default as ShousuushiiYaku } from './yakus/shousuushii-yaku'
38 | export { default as SuuankouYaku } from './yakus/suuankou-yaku'
39 | export { default as SuukantsuYaku } from './yakus/suukantsu-yaku'
40 | export { default as TanyaoYaku } from './yakus/tanyao-yaku'
41 | export { default as TenhouYaku } from './yakus/tenhou-yaku'
42 | export { default as ToitoiYaku } from './yakus/toitoi-yaku'
43 | export { default as TsuuiisouYaku } from './yakus/tsuuiisou-yaku'
44 | export { default as YakuhaiYaku } from './yakus/yakuhai-yaku'
45 |
46 | export { default as HanCalculator } from './han-calculator'
47 |
--------------------------------------------------------------------------------
/src/core/han-calculation/yaku.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Yaku interface
3 | *
4 | * @interface Yaku
5 | * @memberof HanCalculation
6 | */
7 |
8 | /**
9 | * Function called by the han calculator to know what han are allowed according to this yaku.
10 | *
11 | * @function
12 | * @name HanCalculation.Yaku#check
13 | * @param {Hand} hand - Hand to check the yaku onto
14 | * @returns {(undefined|HanCalculation.HanInfo|HanCalculation.HanInfo[])}
15 | */
16 |
--------------------------------------------------------------------------------
/src/core/han-calculation/yakus/chankan-yaku.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Chankan (Robbing the kan) yaku pattern
3 | *
4 | * Winning on off a tile used to extend a kong.
5 | *
6 | * A hand with (1-1-1-2-3-4-5-6-7-8-9-9-9) of the same suit and an other tile of the same suit
7 | * Worth two yakuman if the hand was waiting on nine different tiles (Junsei Chuuren Poutou)
6 | *
7 | * A hand with one of each dragon, wind and 1 and 9 of each suit, plus an other tile to make a pair
8 | * Worth two yakuman if the hand was waiting on 13 different tiles (Kokushi Musou 13 men machi)
3 | *
4 | * The principle works exactly in the same way as the original riichi. However, there is an added bonus of 1-han attached, which is earned by revealing either the hand or the tile waits.
9 | *
10 | * A hand with no fu except the one for winning
11 | * Just sequence, no pair point (dragon or seat/prevalent wind) and a two-sided wait (only wait that give no fu)
6 | *
7 | * A hand that has four closed pons/kans
8 | * In the case of a single-tile wait for the pair, the tile can either be self-drawn or won from another player's discard, and it is worth two yakuman