(a: T[], b: U[]): [T, U][] => {
7 | return a
8 | .map(a => b.map(b => [a, b]))
9 | .reduce((acc, cur) => [...acc, ...cur], []) as [T, U][];
10 | };
11 |
12 | export const memoize = (
13 | f: (...params: P) => R,
14 | serialize: (...params: P) => string
15 | ): ((...params: P) => R) => {
16 | const memo: { [key: string]: R } = {};
17 | return (...params: P) => {
18 | const serialized = serialize(...params);
19 | if (typeof memo[serialized] === 'undefined')
20 | memo[serialized] = f(...params);
21 | return memo[serialized] as R;
22 | };
23 | };
24 |
25 | export const uniqueSorted = (
26 | a: T[],
27 | compare: (a: T, b: T) => boolean
28 | ): T[] => {
29 | if (a.length === 0) return [];
30 |
31 | const [first, ...rest] = a;
32 | assertNonNullable(first);
33 | return rest.reduce(
34 | (acc, cur) =>
35 | compare(acc[acc.length - 1] as T, cur) ? acc : [...acc, cur],
36 | [first]
37 | );
38 | };
39 |
40 | export const groupBy = (
41 | a: T[],
42 | f: (e: T, i: number) => U | null
43 | ) =>
44 | a.reduce(
45 | (acc, cur, i) => {
46 | const key = f(cur, i);
47 | if (key === null) return acc;
48 | return { ...acc, [key]: [...(acc[key] ?? []), cur] };
49 | },
50 | {} as { [_ in U]?: T[] }
51 | );
52 |
53 | export const countBy = (a: T[], f: (e: T, i: number) => boolean) =>
54 | a.reduce((acc, cur, i) => acc + (f(cur, i) ? 1 : 0), 0);
55 |
56 | export const countGroupBy = (
57 | a: T[],
58 | f: (e: T, i: number) => U | null
59 | ) =>
60 | a.reduce(
61 | (acc, cur, i) => {
62 | const key = f(cur, i);
63 | if (key === null) return acc;
64 | return { ...acc, [key]: (acc[key] ?? 0) + 1 };
65 | },
66 | {} as { [_ in U]?: number }
67 | );
68 |
69 | export const sumBy = (
70 | a: T[],
71 | f: (e: T, i: number) => number,
72 | initialValue = 0
73 | ) => a.reduce((acc, cur, i) => acc + f(cur, i), initialValue);
74 |
75 | export const minsBy = (a: T[], f: (e: T, i: number) => number) =>
76 | a.reduce(
77 | (acc, cur, i) => {
78 | const c = f(cur, i);
79 | if (c < acc[0]) return [c, [cur]] as [number, T[]];
80 | if (c === acc[0]) return [acc[0], [...acc[1], cur]] as [number, T[]];
81 | return acc;
82 | },
83 | [Number.POSITIVE_INFINITY, []] as [number, T[]]
84 | );
85 |
86 | export const shuffle = (a: T[]) => {
87 | const ret = [...a];
88 | for (let i = ret.length - 1; i > 0; i--) {
89 | const j = Math.floor(Math.random() * (i + 1));
90 | [ret[i], ret[j]] = [ret[j] as T, ret[i] as T];
91 | }
92 | return ret;
93 | };
94 |
95 | export const unreachable = (message?: string) => {
96 | throw new Error(message ?? 'Entered unreachable code');
97 | };
98 |
--------------------------------------------------------------------------------
/src/components/PointDiff.tsx:
--------------------------------------------------------------------------------
1 | import type { FC } from 'react';
2 | import { useTranslation } from 'react-i18next';
3 | import { useStore } from '../contexts/store';
4 | import { sumOfFu } from '../lib/fu';
5 | import type { Hora } from '../lib/hora';
6 | import { calculateBasePoint, ceil100 } from '../lib/score';
7 | import { sumBy } from '../lib/util';
8 |
9 | interface PointDiffProps {
10 | info: Hora;
11 | }
12 |
13 | export const PointDiff: FC = ({ info }) => {
14 | const [
15 | {
16 | currentRule: {
17 | roundedMangan,
18 | accumlatedYakuman,
19 | multipleYakuman,
20 | honbaBonus
21 | },
22 | table
23 | }
24 | ] = useStore();
25 | const { t } = useTranslation();
26 |
27 | if (info.yaku.every(y => y.name === 'dora' || y.name === 'red-dora'))
28 | return null;
29 |
30 | const base =
31 | info.type === 'kokushi' || info.yaku.some(y => y.type === 'yakuman')
32 | ? info.yaku.reduce((acc, cur) => {
33 | const p = cur.type === 'yakuman' ? cur.point : 0;
34 | if (multipleYakuman) return acc + p;
35 | return Math.max(acc, p);
36 | }, 0) * 8000
37 | : info.yaku.every(y => y.name === 'dora' || y.name === 'red-dora')
38 | ? 0
39 | : calculateBasePoint(
40 | info.type === 'mentsu' ? sumOfFu(info.fu) : 25,
41 | sumBy(info.yaku, y => (y.type === 'yaku' ? y.han : 0)),
42 | roundedMangan,
43 | accumlatedYakuman
44 | );
45 | const isDealer = table.seat === 'east';
46 |
47 | return (
48 |
49 |
{t('result.point-diff')}
50 | {info.by === 'ron' && (
51 |
52 | {t('result.point', {
53 | count:
54 | (ceil100(base * (isDealer ? 6 : 4)) +
55 | table.continue * 3 * honbaBonus) *
56 | 2 +
57 | 1000 * table.deposit
58 | })}
59 |
60 | )}
61 | {info.by === 'tsumo' && isDealer && (
62 |
63 | {t('result.point', {
64 | count:
65 | (ceil100(base * 2) + table.continue * honbaBonus) * 4 +
66 | 1000 * table.deposit
67 | })}
68 |
69 | )}
70 | {info.by === 'tsumo' && !isDealer && (
71 | <>
72 |
73 | {t('result.non-dealer-diff', {
74 | count:
75 | ceil100(base) * 3 +
76 | ceil100(base * 2) +
77 | table.continue * honbaBonus * 4 +
78 | 1000 * table.deposit
79 | })}
80 |
81 |
82 | {t('result.dealer-diff', {
83 | count:
84 | ceil100(base) * 2 +
85 | ceil100(base * 2) * 2 +
86 | table.continue * honbaBonus * 4 +
87 | 1000 * table.deposit
88 | })}
89 |
90 |
91 | )}
92 |
17 |
22 |
23 |
24 |
25 | {t('keyboard-shortcuts.title')}
26 |
27 |
28 |
←↓↑→
29 |
{t('keyboard-shortcuts.switch-focus')}
30 |
{formatKeys('Backspace')}
31 |
{t('keyboard-shortcuts.delete-tile')}
32 |
12m34p56s0m
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
1234567z
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
{formatKeys('Shift+P')}
53 |
{t('keyboard-shortcuts.pon')}
54 |
{formatKeys('Shift+C')}
55 |
{t('keyboard-shortcuts.chii')}
56 |
{formatKeys('Shift+M')}
57 |
{t('keyboard-shortcuts.minkan')}
58 |
{formatKeys('Shift+A')}
59 |
{t('keyboard-shortcuts.ankan')}
60 |
{formatKeys('Shift+R')}
61 |
{t('keyboard-shortcuts.toggle-red')}
62 |
63 |
64 |
65 |
66 |
36 |
37 |
38 |
49 |
50 |
54 |
55 |
59 |
60 |
61 |
62 |
63 |
67 |
68 |
69 |
70 |
19 |
20 |
21 |
22 | t(`table-settings.${w}`))}
24 | index={winds.indexOf(table.round)}
25 | onChange={i =>
26 | dispatch({
27 | type: 'set-table',
28 | payload: { ...table, round: winds[i] as Wind }
29 | })
30 | }
31 | />
32 |
33 |
34 |
35 |
36 | t(`table-settings.${w}`))}
38 | index={winds.indexOf(table.seat)}
39 | onChange={i =>
40 | dispatch({
41 | type: 'set-table',
42 | payload: { ...table, seat: winds[i] as Wind }
43 | })
44 | }
45 | />
46 |
47 |
48 |
49 |
50 |
51 |
54 | {t('table-settings.deposit')}
55 |
56 |
57 | }
58 | >
59 |
0}
62 | onChange={value =>
63 | dispatch({
64 | type: 'set-table',
65 | payload: { ...table, deposit: value }
66 | })
67 | }
68 | />
69 |
70 |
71 |
72 |
75 | {t('table-settings.continue')}
76 |
77 |
78 | }
79 | >
80 |
0}
83 | onChange={value =>
84 | dispatch({
85 | type: 'set-table',
86 | payload: { ...table, continue: value }
87 | })
88 | }
89 | />
90 |
91 |
21 |
22 |
26 | {t('locale:name')}
27 |
28 | {i18n.resolvedLanguage}
29 |
30 |
36 | {languages.map(lng => (
37 |
64 | ))}
65 |
36 |
38 | dispatch({
39 | type: 'set-table',
40 | payload: {
41 | ...table,
42 | seat: table.seat === 'east' ? 'south' : 'east'
43 | }
44 | })
45 | }
46 | >
47 | {t(isDealer ? 'scoring-table.dealer' : 'scoring-table.non-dealer')}
48 |
49 |
50 |
setOpenTableSettings(o => !o)}
53 | >
54 |
55 | {currentScoringTableTab === 'diff' && (
56 |
57 |
58 |
{table.deposit}
59 |
60 | )}
61 |
62 |
63 |
{table.continue}
64 |
65 |
67 | {openTableSettings && (
68 |
69 | {currentScoringTableTab === 'diff' && (
70 | 0}
72 | onChange={d =>
73 | dispatch({
74 | type: 'set-table',
75 | payload: { ...table, deposit: table.deposit + d }
76 | })
77 | }
78 | />
79 | )}
80 | 0}
82 | onChange={d =>
83 | dispatch({
84 | type: 'set-table',
85 | payload: { ...table, continue: table.continue + d }
86 | })
87 | }
88 | />
89 |
90 | )}
91 |
92 |
14 | {children}
15 |
16 | );
17 |
18 | interface ResultProps {
19 | result: ResultType;
20 | }
21 | export const Result: FC = ({ result }) => {
22 | const { t } = useTranslation();
23 |
24 | if (result === null) {
25 | return {t('result.input-message')};
26 | }
27 |
28 | if (result.type === 'just-hora') {
29 | return {t('result.hora')};
30 | }
31 |
32 | if (result.type === 'hora-shanten') {
33 | if (result.info.type === 'hora') {
34 | if (result.info.hora.length === 0) {
35 | return {t('result.no-hora-tiles')};
36 | }
37 | return (
38 |
39 | {result.info.hora.map(hora => (
40 |
44 | ))}
45 |
46 | );
47 | }
48 | return (
49 |
53 | );
54 | }
55 |
56 | if (result.type === 'tempai') {
57 | if (result.tileAvailabilities.every(a => a.count === 0)) {
58 | return {t('result.no-hora-tiles')};
59 | }
60 | return ;
61 | }
62 |
63 | if (result.type === 'discard-shanten') {
64 | const shanten = result.discards.reduce(
65 | (acc, cur) =>
66 | Math.min(
67 | acc,
68 | cur.next.type === 'tempai'
69 | ? 0
70 | : cur.next.info.type === 'hora'
71 | ? 0
72 | : cur.next.info.shanten
73 | ),
74 | Number.POSITIVE_INFINITY
75 | );
76 | const discards = [...result.discards];
77 | if (
78 | discards.every(
79 | d => d.next.type === 'hora-shanten' && d.next.info.type === 'shanten'
80 | )
81 | ) {
82 | discards.sort((a, b) => {
83 | if (
84 | a.next.type !== 'hora-shanten' ||
85 | a.next.info.type !== 'shanten' ||
86 | b.next.type !== 'hora-shanten' ||
87 | b.next.info.type !== 'shanten'
88 | )
89 | throw new Error();
90 |
91 | const ac = sumBy(a.next.info.tileAvailabilities, a => a.count);
92 | const bc = sumBy(b.next.info.tileAvailabilities, a => a.count);
93 |
94 | if (ac === bc) return compareTiles(a.tile, b.tile);
95 | return bc - ac;
96 | });
97 | }
98 |
99 | return (
100 |
101 |
102 | {shanten === 0
103 | ? t('result.tempai')
104 | : t('result.shanten', { count: shanten })}
105 |
106 |
107 | {discards.map((d, i) => (
108 |
109 | ))}
110 |
111 |
117 | {JSON.stringify(result, null, 2)}
118 |
119 | );
120 | };
121 |
--------------------------------------------------------------------------------
/src/components/tile/images/dark/1m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/light/1m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/wasm/decomposer/src/counts.rs:
--------------------------------------------------------------------------------
1 | use std::ops::Add;
2 |
3 | use serde::{Serialize, Serializer};
4 |
5 | #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
6 | pub struct PackedCounts(u32);
7 |
8 | impl PackedCounts {
9 | pub fn with(counts: &[u8]) -> Self {
10 | if counts.len() != N {
11 | panic!();
12 | }
13 | let mut d = 0;
14 | (0..N).for_each(|i| {
15 | d |= (counts[i] as u32 & 0b111) << (3 * i);
16 | });
17 | Self(d)
18 | }
19 |
20 | pub fn get(&self, index: usize) -> u8 {
21 | ((self.0 >> (3 * index)) & 0b111) as u8
22 | }
23 |
24 | pub fn set(&mut self, index: usize, value: u8) {
25 | self.0 = (self.0 & !(0b111 << (3 * index))) | ((value as u32 & 0b111) << (3 * index));
26 | }
27 |
28 | pub fn set_by(&mut self, index: usize, f: impl FnOnce(u8) -> u8) {
29 | self.set(index, f(self.get(index)))
30 | }
31 |
32 | pub fn iter(&self) -> PackedCountsIterator {
33 | PackedCountsIterator::new(self)
34 | }
35 | }
36 |
37 | impl Add for PackedCounts {
38 | type Output = Self;
39 |
40 | fn add(self, rhs: Self) -> Self::Output {
41 | let a: Vec<_> = self.iter().zip(rhs.iter()).map(|(a, b)| a + b).collect();
42 | Self::with(&a)
43 | }
44 | }
45 |
46 | impl Serialize for PackedCounts {
47 | fn serialize(&self, serializer: S) -> Result
48 | where
49 | S: Serializer,
50 | {
51 | serializer.collect_seq(self.iter())
52 | }
53 | }
54 |
55 | pub struct PackedCountsIterator<'a, const N: usize> {
56 | source: &'a PackedCounts,
57 | index: usize,
58 | }
59 |
60 | impl<'a, const N: usize> PackedCountsIterator<'a, N> {
61 | fn new(source: &'a PackedCounts) -> Self {
62 | Self { source, index: 0 }
63 | }
64 | }
65 |
66 | impl Iterator for PackedCountsIterator<'_, N> {
67 | type Item = u8;
68 |
69 | fn next(&mut self) -> Option {
70 | if self.index == N {
71 | None
72 | } else {
73 | let value = self.source.get(self.index);
74 | self.index += 1;
75 | Some(value)
76 | }
77 | }
78 | }
79 |
80 | pub type PackedNumberCounts = PackedCounts<9>;
81 | pub type PackedCharacterCounts = PackedCounts<7>;
82 |
83 | #[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
84 | pub struct Counts {
85 | pub m: PackedNumberCounts,
86 | pub p: PackedNumberCounts,
87 | pub s: PackedNumberCounts,
88 | pub z: PackedCharacterCounts,
89 | }
90 |
91 | impl Counts {
92 | pub fn new() -> Self {
93 | Default::default()
94 | }
95 |
96 | pub fn with(counts: &[u8]) -> Self {
97 | if counts.len() != 34 {
98 | panic!();
99 | }
100 | Self {
101 | m: PackedNumberCounts::with(&counts[0..9]),
102 | p: PackedNumberCounts::with(&counts[9..18]),
103 | s: PackedNumberCounts::with(&counts[18..27]),
104 | z: PackedCharacterCounts::with(&counts[27..34]),
105 | }
106 | }
107 | }
108 |
109 | impl Add for Counts {
110 | type Output = Self;
111 |
112 | fn add(self, rhs: Self) -> Self::Output {
113 | Self {
114 | m: self.m + rhs.m,
115 | p: self.p + rhs.p,
116 | s: self.s + rhs.s,
117 | z: self.z + rhs.z,
118 | }
119 | }
120 | }
121 |
122 | impl Serialize for Counts {
123 | fn serialize(&self, serializer: S) -> Result
124 | where
125 | S: Serializer,
126 | {
127 | serializer.collect_seq(
128 | self.m
129 | .iter()
130 | .chain(self.p.iter())
131 | .chain(self.s.iter())
132 | .chain(self.z.iter()),
133 | )
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/src/components/tile/images/dark/2m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/light/2m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/dark/8m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/light/8m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/dark/3m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/light/3m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/dark/7m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/tile/images/light/7m.svg:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/src/components/ResultGlance.tsx:
--------------------------------------------------------------------------------
1 | import type { FC } from 'react';
2 | import { useTranslation } from 'react-i18next';
3 | import { useWindowSize } from '../hooks/dom';
4 | import type { Result } from '../lib/result';
5 | import { compareTiles } from '../lib/tile';
6 | import { uniqueSorted } from '../lib/util';
7 | import { Tile } from './tile';
8 |
9 | const scrollMargin = 48;
10 |
11 | interface ResultGlanceProps {
12 | result: Result;
13 | handOptionsPosition?: number | undefined;
14 | }
15 | export const ResultGlance: FC = ({
16 | result,
17 | handOptionsPosition = Number.POSITIVE_INFINITY
18 | }) => {
19 | const { t } = useTranslation();
20 | const { height } = useWindowSize();
21 |
22 | if (handOptionsPosition - height + scrollMargin < 0 || result === null)
23 | return null;
24 |
25 | return (
26 |
27 | {result.type === 'just-hora' &&
{t('result.hora')}
}
28 | {result.type === 'tempai' &&
29 | result.tileAvailabilities.every(a => a.count === 0) && (
30 |
{t('result.no-hora-tiles')}
31 | )}
32 | {result.type === 'tempai' &&
33 | result.tileAvailabilities.some(a => a.count > 0) && (
34 |
35 |
{t('result.tempai')}
36 |
37 | {result.tileAvailabilities
38 | .filter(a => a.count > 0)
39 | .map((a, i) => (
40 |
41 |
42 |
43 | ))}
44 |
45 |
46 | )}
47 | {result.type === 'discard-shanten' && (
48 |
49 |
50 | {(() => {
51 | const shanten = result.discards.reduce(
52 | (acc, cur) =>
53 | Math.min(
54 | acc,
55 | cur.next.type === 'tempai'
56 | ? 0
57 | : cur.next.info.type === 'hora'
58 | ? 0
59 | : cur.next.info.shanten
60 | ),
61 | Number.POSITIVE_INFINITY
62 | );
63 | return shanten === 0
64 | ? t('result.tempai')
65 | : t('result.shanten', { count: shanten });
66 | })()}
67 |
68 |
{t('result.discard')}
69 |
70 | {result.discards.map((d, i) => (
71 |
72 |
73 |
74 | ))}
75 |
76 |
77 | )}
78 | {result.type === 'hora-shanten' && result.info.type === 'shanten' && (
79 |
80 |
81 | {t('result.shanten', { count: result.info.shanten })}
82 |
83 |
{t('result.acceptance')}
84 |
85 | {result.info.tileAvailabilities.map((a, i) => (
86 |
87 |
88 |
89 | ))}
90 |
91 |
92 | )}
93 | {result.type === 'hora-shanten' && result.info.type === 'hora' && (
94 |
95 |
{t('result.tempai')}
96 |
{t('result.waiting')}
97 |
98 | {uniqueSorted(
99 | result.info.hora.map(h => h.horaTile),
100 | (a, b) => compareTiles(a, b) === 0
101 | ).map((t, i) => (
102 |
103 |
104 |
105 | ))}
106 |
107 |
108 | )}
109 |
15 |
16 |
17 |
18 | t(`hand-options.${o}`))}
20 | index={riichiOptions.indexOf(handOptions.riichi)}
21 | onChange={i =>
22 | dispatch({
23 | type: 'set-hand-options',
24 | payload: {
25 | ...handOptions,
26 | riichi: riichiOptions[i as 0 | 1 | 2]
27 | }
28 | })
29 | }
30 | />
31 |
32 |
33 |
34 |
35 |
39 | dispatch({
40 | type: 'set-hand-options',
41 | payload: { ...handOptions, ippatsu: i === 1 }
42 | })
43 | }
44 | />
45 |
46 |
47 |
48 |
49 |
50 |
51 |
55 | dispatch({
56 | type: 'set-hand-options',
57 | payload: { ...handOptions, rinshan: i === 1 }
58 | })
59 | }
60 | />
61 |
62 |
63 |
64 |
65 |
69 | dispatch({
70 | type: 'set-hand-options',
71 | payload: { ...handOptions, chankan: i === 1 }
72 | })
73 | }
74 | />
75 |
76 |
77 |
78 |
79 |
80 |
81 |
85 | dispatch({
86 | type: 'set-hand-options',
87 | payload: { ...handOptions, haitei: i === 1 }
88 | })
89 | }
90 | />
91 |
92 |
93 |
94 |
101 |
112 | dispatch({
113 | type: 'set-hand-options',
114 | payload: { ...handOptions, tenho: i === 1 }
115 | })
116 | }
117 | />
118 |
119 |
120 |
121 |
56 | {(['m', 'p', 's'] as const).map(type => (
57 |
58 | {([1, 2, 3, 4, 5, 6, 7, 8, 9] as const).map(n => (
59 |
60 | {n === 5 && showNonRed && (
61 |
67 | dispatch({
68 | type: 'click-tile-keyboard',
69 | payload: { type, n, red: false }
70 | })
71 | }
72 | />
73 | )}
74 | {n === 5 && showRed && (
75 |
81 | dispatch({
82 | type: 'click-tile-keyboard',
83 | payload: { type, n, red: true }
84 | })
85 | }
86 | />
87 | )}
88 | {n !== 5 && (
89 |
93 | dispatch({
94 | type: 'click-tile-keyboard',
95 | payload: { type, n }
96 | })
97 | }
98 | />
99 | )}
100 |
101 | ))}
102 |
103 | ))}
104 |
105 | {([1, 2, 3, 4, 5, 6, 7] as const).map(n => (
106 |
111 | dispatch({
112 | type: 'click-tile-keyboard',
113 | payload: { type: 'z', n }
114 | })
115 | }
116 | />
117 | ))}
118 |
119 |
120 | {showNonRed && showRed && }
121 |
122 |