Add HandEnding.faan and .base_points

game.py:
+ HandEnding.faan simply sums Wu.faan and Player.bonus_faan
+ HandEnding.points computes the actual points resulting from
  the faan, as changes to current points of each player
+ game.STOCK_TABLES are stock faan->base-point mappings that come
  with the library; you are free to provide your own in an argument
  to HandEnding.base_points

melds.py:
+ WuFlag.(bonus flags)
* Moved constants because it makes sense

players.py:
* Player.bonus_faan now returns the flags regarding bonuses too

__main__.py:
+ Since running Hands standalone is supported now, do so by default.
  Run a full game with --game cmdarg
+ Show point deltas as well as faan and flags

mahjong/__main__.py

@@ -26,9 +26,13 @@
  print(', '.join(map(str, p.bonus)))
 #'''
 #''' # uncomment this opening triple quote when commenting out one elsewhere
-from mahjong.game import Game, UserIO, Question, HandEnding, HandResult
+import sys
+from mahjong.game import Game, Hand, UserIO, Question, HandEnding, HandResult
 
-game = Game(extra_hands=False)
+if '--game' in sys.argv:
+ game = Game(extra_hands=False)
+else:
+ game = Hand(None)
 print('Note: all indexes are **1-based**.')
 print('This is a rudimentary text-based mahjong implementation.')
 print("It's purely as a proof-of-concept/manual testing method.")
@@ -109,9 +113,9 @@
  print('Goulash! Nobody wins. Starting next game...')
  else:
  assert question.choice is not None
- print('Player #%s won with %s (%s faan; %s)! Starting next game...' % (
+ print('Player #%s won with %s (%s faan; %s points; %s)! Starting next game...' % (
  question.winner.seat.value, ','.join(map(str, question.choice)),
- *question.wu.faan(question.choice, (question.winner.seat, game.round.wind))
+ question.faan()[0], *question.points(1)
  ))
  question = question.answer()
 print('Game Over!')

mahjong/game.py

@@ -26,6 +26,34 @@
  'Turn',
 ]
 
+STOCK_TABLES = {
+ 'enwp': {
+ 1: 1, 2: 1, 3: 1,
+ 4: 2, 5: 2, 6: 2,
+ 7: 4, 8: 4, 9: 4,
+ 10: 8
+ },
+ 'zhwp': {
+ 0: 1, 1: 2, 2: 4, 3: 8,
+ 4: 16, 5: 24, 6: 32, 7: 48,
+ 8: 64, 9: 96, 10: 128, 11: 192,
+ 12: 256, 13: 384
+ },
+ # in the app I play,
+ # 3 faan = 1200c = 1x1200
+ # 4 faan = 2400c = 2x1200
+ # 5 faan = 3600c = 3x1200
+ # 6 faan = 4800c = 4x1200
+ # 7 faan = 7200c = 6x1200
+ # 8 faan = 9600c = 8x1200
+ 'random_app': {
+ 1: 1, 2: 1, 3: 1,
+ 4: 2, 5: 3, 6: 4,
+ 7: 6, 8: 8, 9: 10,
+ 10: 13
+ }
+}
+
 # data classes
 
 def _answer(gen: Generator, ans=None) -> YieldType:
@@ -54,6 +82,71 @@ class HandEnding(NamedTuple):
  def answer(self, ans=None):
  return _answer(self.hand.gen, ans)
 
+ def faan(self) -> Tuple[int, Optional[WuFlag]]:
+ """Calculate the faan for this hand."""
+ if self.winner is None or self.wu is None or self.choice is None:
+ return (0, None)
+ points = self.wu.faan(self.choice, (self.winner.seat, self.hand.wind))
+ bonus = self.winner.bonus_faan()
+ return (points[0] + bonus[0], points[1] | bonus[1])
+
+ def points(self, min_faan: int = 3, table: Mapping[int, int] = None) \
+ -> Tuple[List[int], Optional[WuFlag]]:
+ """Calculate the change in points for each player.
+
+ Parameters
+ -----------
+ ``min_faan``: int
+ Minimum faan before the hand is recognized as a valid winning hand
+ ``table``: Mapping[int, int]
+ Mapping of faan to base points. The largest faan value is assumed
+ to be the limit, and values larger than it will be mapped to it.
+
+ Returns
+ --------
+ Tuple[List[int], Optional[WuFlag]]
+ A list of four point deltas, representing each player, and
+ the flags that apply to this hand. The former is four zeroes,
+ and the latter is None, on goulash or not enough faan.
+ """
+ points = [0, 0, 0, 0]
+ if self.winner is None:
+ return (points, None)
+ faan, flags = self.faan()
+ if faan < min_faan:
+ return (points, None)
+ winner = self.winner
+ wu = self.wu
+ if table is None:
+ table = STOCK_TABLES['random_app']
+ limit = max(table.keys())
+ base = table[min(faan, limit)]
+ # special penalties that make the perpetrator pay
+ # for everyone else on top of themselves
+ if ((WuFlag.TWELVE_PIECE in wu.flags and WuFlag.SELF_DRAW in wu.flags)
+ or (WuFlag.GAVE_KONG in wu.flags and WuFlag.SELF_DRAW in wu.flags)
+ or WuFlag.GAVE_DRAGON in wu.flags) and wu.discarder is not None:
+ points[winner.seat] += base * 3
+ points[wu.discarder] -= base * 3
+ # loser pays double in normal losing conditions
+ elif wu.discarder is not None:
+ points[winner.seat] += base * 2
+ points[wu.discarder] -= base * 2
+ # self draw means everyone pays
+ elif WuFlag.SELF_DRAW in wu.flags:
+ for i in range(4):
+ if i == winner.seat:
+ points[i] += base * 3
+ else:
+ points[i] -= base
+ else:
+ raise ValueError('Somehow, nobody gets points. '
+ 'Possibly report to maintainer with '
+ 'the following information: '
+ + str(self.wu.__dict__)
+ + ' ;; ' + str(self.winner.__dict__))
+ return (points, flags)
+
 class Question(Enum):
  MELD_FROM_DISCARD_Q = 16
  SHOW_EKFCP_Q = 23

mahjong/melds.py

@@ -57,6 +57,42 @@ class WuFlag(Flag):
  GAVE_DRAGON = 1 << 29
  GAVE_KONG = 1 << 30
 
+ # bonuses
+ NO_BONUSES = 1 << 31
+ ALIGNED_FLOWERS = 1 << 32
+ ALIGNED_SEASONS = 1 << 33
+ TABLE_OF_FLOWERS = 1 << 34
+ TABLE_OF_SEASONS = 1 << 35
+ HAND_OF_BONUSES = 1 << 36
+
+# special case: 1 & 9 of each suit + every value of honors suits
+THIRTEEN_ORPHANS = set(map(Tile.from_str, (
+ 'tong/1|tong/9|zhu/1|zhu/9|wan/1|wan/9|' # simples
+ 'feng/1|feng/2|feng/3|feng/4|long/1|long/2|long/3' # honors
+).split('|')))
+
+FLAG_FAAN = {
+ WuFlag.CHICKEN_HAND: 0,
+ WuFlag.COMMON_HAND: 1, WuFlag.ALL_IN_TRIPLETS: 3,
+ WuFlag.ALL_HONOR_TILES: 10, WuFlag.ALL_ONE_SUIT: 7,
+ WuFlag.MIXED_ONE_SUIT: 3, WuFlag.GREAT_DRAGONS: 8,
+ WuFlag.SMALL_DRAGONS: 5, WuFlag.GREAT_WINDS: 13,
+ WuFlag.SMALL_WINDS: 10, WuFlag.THIRTEEN_ORPHANS: 13,
+ WuFlag.ALL_KONGS: 13, WuFlag.SELF_TRIPLETS: 8,
+ WuFlag.ORPHANS: 10, WuFlag.NINE_GATES: 10,
+ WuFlag.RED_DRAGON: 1, WuFlag.GREAT_WINDS: 1,
+ WuFlag.WHITE_DRAGON: 1, WuFlag.SEAT_WIND: 1,
+ WuFlag.PREVAILING_WIND: 1, WuFlag.MIXED_ORPHANS: 1,
+ WuFlag.SELF_DRAW: 1, WuFlag.ALL_FROM_WALL: 1,
+ WuFlag.ROBBING_KONG: 1, WuFlag.LAST_CATCH: 1,
+ WuFlag.BY_KONG: 1, WuFlag.DOUBLE_KONG: 8,
+ WuFlag.HEAVENLY: 13, WuFlag.EARTHLY: 13,
+ WuFlag.TWELVE_PIECE: 0, WuFlag.GAVE_DRAGON: 0, WuFlag.GAVE_KONG: 0,
+ WuFlag.NO_BONUSES: 1, WuFlag.ALIGNED_FLOWERS: 1,
+ WuFlag.ALIGNED_SEASONS: 1, WuFlag.TABLE_OF_FLOWERS: 2,
+ WuFlag.TABLE_OF_SEASONS: 2, WuFlag.HAND_OF_BONUSES: 8,
+}
+
 def _tname(obj) -> str:
  return type(obj).__name__
 
@@ -512,33 +548,6 @@ def __init__(
  tile for meld in (melds or []) for tile in meld.tiles)
  self.fixed_melds = []
 
-# special case: 1 & 9 of each suit + every value of honors suits
-THIRTEEN_ORPHANS = set(_UncheckedWu.from_str(
- 'tong/1|tong/9|zhu/1|zhu/9|wan/1|wan/9|' # simples
- 'feng/1|feng/2|feng/3|feng/4|long/1|long/2|long/3' # honors
-).tiles)
-
-FLAG_FAAN = {
- WuFlag.CHICKEN_HAND: 0,
- WuFlag.COMMON_HAND: 1, WuFlag.ALL_IN_TRIPLETS: 3,
- WuFlag.ALL_HONOR_TILES: 10, WuFlag.ALL_ONE_SUIT: 7,
- WuFlag.MIXED_ONE_SUIT: 3, WuFlag.GREAT_DRAGONS: 8,
- WuFlag.SMALL_DRAGONS: 5, WuFlag.GREAT_WINDS: 13,
- WuFlag.SMALL_WINDS: 10, WuFlag.THIRTEEN_ORPHANS: 13,
- WuFlag.ALL_KONGS: 13, WuFlag.SELF_TRIPLETS: 8,
- WuFlag.ORPHANS: 10, WuFlag.NINE_GATES: 10,
- WuFlag.RED_DRAGON: 1, WuFlag.GREAT_WINDS: 1,
- WuFlag.WHITE_DRAGON: 1, WuFlag.SEAT_WIND: 1,
- WuFlag.PREVAILING_WIND: 1, WuFlag.MIXED_ORPHANS: 1,
- WuFlag.SELF_DRAW: 1, WuFlag.ALL_FROM_WALL: 1,
- WuFlag.ROBBING_KONG: 1, WuFlag.LAST_CATCH: 1,
- WuFlag.BY_KONG: 1, WuFlag.DOUBLE_KONG: 8,
- WuFlag.HEAVENLY: 13, WuFlag.EARTHLY: 13,
- WuFlag.NO_BONUSES: 1, WuFlag.ALIGNED_FLOWERS: 1,
- WuFlag.ALIGNED_SEASONS: 1, WuFlag.TABLE_OF_FLOWERS: 2,
- WuFlag.TABLE_OF_SEASONS: 2, WuFlag.HAND_OF_BONUSES: 8,
-}
-
 if 0:
  # TODO: figure out why one particular one takes multiple seconds:
  # 1.25s (3.94s when debug): tong/1|tong/1|tong/1|tong/2|tong/2|tong/2|tong/3|tong/3|tong/3|tong/4|tong/4|tong/4|tong/5|tong/5

mahjong/players.py

@@ -1,6 +1,6 @@
-from typing import List
+from typing import List, Tuple
 from .tiles import Bonuses, Tile, BonusTile, Wind
-from .melds import Meld
+from .melds import Meld, WuFlag, faan
 
 class Player:
  """Represents one Mahjong player."""
@@ -45,22 +45,32 @@ def show_meld(self, discard: Tile, meld: Meld):
  self.hand.remove(tile)
  self.shown.append(meld) # Step 19
 
- def bonus_faan(self) -> int:
+ def bonus_faan(self) -> Tuple[int, WuFlag]:
  """Get faan won from bonus tiles or lack thereof."""
- points = 0
+ flags = WuFlag.CHICKEN_HAND
  if not self.bonus:
- points += 1 # :(
+ flags |= WuFlag.NO_BONUSES
  found = {
  Bonuses.GUI: [False]*4,
  Bonuses.HUA: [False]*4
  }
  for tile in self.bonus:
  if tile.number == self.seat:
- points += 1
+ if tile.suit == Bonuses.HUA:
+ flags |= WuFlag.ALIGNED_FLOWERS
+ elif tile.suit == Bonuses.GUI:
+ flags |= WuFlag.ALIGNED_SEASONS
  found[tile.suit][tile.number] = True
- for v in found.values():
+ for k, v in found.items():
  if all(v):
- points += 1
+ if k == Bonuses.HUA:
+ flags |= WuFlag.TABLE_OF_FLOWERS
+ elif k == Bonuses.GUI:
+ flags |= WuFlag.TABLE_OF_SEASONS
  if all(map(all, found.values())):
- points += 8
- return points
+ flags = WuFlag.HAND_OF_BONUSES
+ if WuFlag.TABLE_OF_FLOWERS in flags:
+ flags &= ~(WuFlag.ALIGNED_FLOWERS)
+ if WuFlag.TABLE_OF_SEASONS in flags:
+ flags &= ~(WuFlag.ALIGNED_SEASONS)
+ return (faan(flags), flags)