mahjong

package module
v0.0.0-...-d9674e8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 5, 2021 License: MIT Imports: 10 Imported by: 0

README

mahjong

A library of Japanese Mahjong for cli-game, server, etc. It may support other Mahjong at future.

Command

  • init 初始化/初期化
  • start 开始/開始
    • shuffle 洗牌/シャッフル
    • stack 排列/並ぶ
    • haipai 发牌/配牌
  • draw 摸牌/ドロー
  • dahai 打牌/だはい
  • chii 吃/チー
  • pon 碰/ポン
  • kan 杠/カン
    • Kan 明杠/明槓
    • AnKan 暗杠/暗槓
    • KaKan 加杠/加槓
  • riichi 立直/リーチ
  • ron 荣和/ロン
  • tsumo 自摸/ツモ
  • restart 流局/流局

Documentation

Index

Constants

View Source 
const (
	TonBa = EastField
	NanBa = SouthField

	PeiBa = NorthField
)

Variables

View Source 
var TilesName = map[TileType]string{
	Dots1:       "1p",
	Dots2:       "2p",
	Dots3:       "3p",
	Dots4:       "4p",
	Dots5:       "5p",
	Dots6:       "6p",
	Dots7:       "7p",
	Dots8:       "8p",
	Dots9:       "9p",
	Bamboo1:     "1s",
	Bamboo2:     "2s",
	Bamboo3:     "3s",
	Bamboo4:     "4s",
	Bamboo5:     "5s",
	Bamboo6:     "6s",
	Bamboo7:     "7s",
	Bamboo8:     "8s",
	Bamboo9:     "9s",
	Characters1: "1m",
	Characters2: "2m",
	Characters3: "3m",
	Characters4: "4m",
	Characters5: "5m",
	Characters6: "6m",
	Characters7: "7m",
	Characters8: "8m",
	Characters9: "9m",
	East:        "1z",
	South:       "2z",
	West:        "3z",
	North:       "4z",
	White:       "5z",
	Green:       "6z",
	Red:         "7z",
}
View Source 
var YakuTachi = []Yaku{
	{
		Name:  "立直",
		FanFR: 役無,
		FanMZ: 一飜,
		Check: WinningHand.readyHand,
		Upgrade: []Yaku{
			{
				Name:  "ダブル立直",
				FanFR: 役無,
				FanMZ: 二飜,
				Check: WinningHand.doubleReady,
			},
		},
	},
	{
		Name:  "一発",
		FanFR: 役無,
		FanMZ: 一飜,
		Check: WinningHand.oneShot,
	},
	{
		Name:  "門前清自摸和",
		FanFR: 役無,
		FanMZ: 一飜,
		Check: WinningHand.selfPick,
	},
	{
		Name:  "断么九",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.allSimples,
	},
	{
		Name:  "平和",
		FanFR: 役無,
		FanMZ: 一飜,
		Check: WinningHand.allRuns,
	},
	{
		Name:  "一盃口",
		FanFR: 役無,
		FanMZ: 一飜,
		Check: WinningHand.doubleRun,
		Upgrade: []Yaku{
			{
				Name:  "二盃口",
				FanFR: 役無,
				FanMZ: 三飜,
				Check: WinningHand.twoDoubleRuns,
			},
		},
	},
	{
		Name:  "役牌(仮)",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.honorTiles,
		Upgrade: []Yaku{
			{
				Name:  "場風牌",
				FanFR: 一飜,
				FanMZ: 一飜,
				Check: WinningHand.prevailingWind,
			},
			{
				Name:  "門風牌",
				FanFR: 一飜,
				FanMZ: 一飜,
				Check: WinningHand.playerWind,
			},
			{
				Name:  "役牌白",
				FanFR: 一飜,
				FanMZ: 一飜,
				Check: WinningHand.whiteDragon,
			},
			{
				Name:  "役牌發",
				FanFR: 一飜,
				FanMZ: 一飜,
				Check: WinningHand.greenDragon,
			},
			{
				Name:  "役牌中",
				FanFR: 一飜,
				FanMZ: 一飜,
				Check: WinningHand.redDragon,
			},
		},
	},
	{
		Name:  "嶺上開花",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.kingsTileDraw,
	},
	{
		Name:  "搶槓",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.addAQuad,
	},
	{
		Name:  "海底摸月",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.finalTurnWinSeaMoon,
	},
	{
		Name:  "河底撈魚",
		FanFR: 一飜,
		FanMZ: 一飜,
		Check: WinningHand.finalTurnWinRiverFish,
	},
	{
		Name:  "三色同順",
		FanFR: 一飜,
		FanMZ: 二飜,
		Check: WinningHand.threeColorRuns,
	},
	{
		Name:  "一気通貫",
		FanFR: 一飜,
		FanMZ: 二飜,
		Check: WinningHand.fullStraight,
	},
	{
		Name:  "混全帯么九",
		FanFR: 一飜,
		FanMZ: 二飜,
		Check: WinningHand.terminalOrHonorInEachSet,
		Upgrade: []Yaku{
			{
				Name:  "混老頭",
				FanFR: 二飜,
				FanMZ: 二飜,
				Check: WinningHand.allTerminalsAndHonors,
			},
			{
				Name:  "純全帯么九",
				FanFR: 二飜,
				FanMZ: 三飜,
				Check: WinningHand.terminalInEachSet,
			},
		},
	},
	{
		Name:  "七対子",
		FanFR: 役無,
		FanMZ: 二飜,
		Check: WinningHand.sevenPairs,
	},
	{
		Name:  "対々和",
		FanFR: 二飜,
		FanMZ: 二飜,
		Check: WinningHand.allTripletHand,
	},
	{
		Name:  "三暗刻",
		FanFR: 二飜,
		FanMZ: 二飜,
		Check: WinningHand.threeClosedTriples,
	},
	{
		Name:  "三色同刻",
		FanFR: 二飜,
		FanMZ: 二飜,
		Check: WinningHand.threeColourTriplets,
	},
	{
		Name:  "三槓子",
		FanFR: 二飜,
		FanMZ: 二飜,
		Check: WinningHand.threeKans,
	},
	{
		Name:  "小三元",
		FanFR: 二飜,
		FanMZ: 二飜,
		Check: WinningHand.littleThreeDragons,
	},
	{
		Name:  "混一色",
		FanFR: 二飜,
		FanMZ: 三飜,
		Check: WinningHand.halfFlush,
		Upgrade: []Yaku{
			{
				Name:  "清一色",
				FanFR: 五飜,
				FanMZ: 六飜,
				Check: WinningHand.fullFlush,
			},
		},
	},
	{
		Name:  "国士無双",
		FanFR: 役無,
		FanMZ: 役満,
		Check: WinningHand.thirteenOrphans,
	},
	{
		Name:  "四暗刻",
		FanFR: 役無,
		FanMZ: 役満,
		Check: WinningHand.fourConcealedTriples,
	},
	{
		Name:  "大三元",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.bigThreeDragons,
	},
	{
		Name:  "字一色",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.allHonors,
	},
	{
		Name:  "小四喜",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.littleFourWinds,
	},
	{
		Name:  "大四喜",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.bigFourWinds,
	},
	{
		Name:  "緑一色",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.allGreen,
	},
	{
		Name:  "清老頭",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.allTerminals,
	},
	{
		Name:  "四槓子",
		FanFR: 役満,
		FanMZ: 役満,
		Check: WinningHand.fourKans,
	},
	{
		Name:  "九蓮宝燈",
		FanFR: 役無,
		FanMZ: 役満,
		Check: WinningHand.nineGates,
	},
	{
		Name:  "天和",
		FanFR: 役無,
		FanMZ: 役満,
		Check: WinningHand.heavenlyHand,
	},
	{
		Name:  "地和",
		FanFR: 役無,
		FanMZ: 役満,
		Check: WinningHand.handOfEarth,
	},
}
View Source 
var Yaochu = []TileType{Dots1, Dots9, Bamboo1, Bamboo9, Characters1, Characters9, East, South, West, North, White, Green, Red}

Functions

func Ceil 

func Ceil(src int, degree int) int

func GetIndexes 

func GetIndexes(tiles []Tile, n ...int8) ([]int, error)

func IsXX 

func IsXX(ttA, ttB TileType) bool

func IsXXX 

func IsXXX(ttA, ttB, ttC TileType) bool

func IsXXXX 

func IsXXXX(ttA, ttB, ttC, ttD TileType) bool

func IsXYZ 

func IsXYZ(ttA, ttB, ttC TileType) bool

func RemoveIndexes 

func RemoveIndexes(tiles *[]Tile, n ...int)

Types

type Agari 

type Agari struct {
	YakuTachi []Yaku
	Fu        int
}

type BaseRule 

type BaseRule struct {
	Maj *Mahjong
}

func (*BaseRule) Init 

func (rule *BaseRule) Init(maj *Mahjong)

type DiscardTile 

type DiscardTile struct {
	Tile
	Jun
	TsumoGiri bool
}

type Fan 

type Fan int8

func CountFan 

func CountFan(yakuTachi []Yaku, menZen bool) Fan

type FieldWind 

type FieldWind int8
const (
	EastField FieldWind = iota
	SouthField
	WestField
	NorthField
)

type FuuroType 

type FuuroType int8
const (
	MinKo FuuroType = iota
	AnKo
	MinKan
	AnKan
	ShunTsu
)

type JapaneseBaseRule 

type JapaneseBaseRule struct {
	BaseRule
}

func (JapaneseBaseRule) Agaris 

func (rule JapaneseBaseRule) Agaris(player *Player, last Tile) []Agari

func (JapaneseBaseRule) CanAgari 

func (rule JapaneseBaseRule) CanAgari(player *Player, last Tile) ([]Agari, error)

func (JapaneseBaseRule) CanNineYaochus 

func (rule JapaneseBaseRule) CanNineYaochus(player *Player) error

途中流局

func (JapaneseBaseRule) CanRiichi 

func (rule JapaneseBaseRule) CanRiichi(player *Player) ([]Tile, error)

func (JapaneseBaseRule) CanRon 

func (rule JapaneseBaseRule) CanRon(player *Player) ([]Agari, error)

func (JapaneseBaseRule) CanTsumo 

func (rule JapaneseBaseRule) CanTsumo(player *Player) ([]Agari, error)

func (JapaneseBaseRule) DoraHints 

func (rule JapaneseBaseRule) DoraHints(count uint8, ura bool) []uint8

func (JapaneseBaseRule) FuriTen 

func (rule JapaneseBaseRule) FuriTen(player *Player) bool

func (JapaneseBaseRule) NineYaochus 

func (rule JapaneseBaseRule) NineYaochus(player *Player) error

func (JapaneseBaseRule) PlayersSitDown 

func (JapaneseBaseRule) PlayersSitDown() Players

func (JapaneseBaseRule) Riichi 

func (rule JapaneseBaseRule) Riichi(player *Player, tile Tile) error

func (JapaneseBaseRule) Ron 

func (rule JapaneseBaseRule) Ron(player *Player) error

func (JapaneseBaseRule) RyanShanAmount 

func (JapaneseBaseRule) RyanShanAmount() uint8

func (JapaneseBaseRule) TileAmount 

func (JapaneseBaseRule) TileAmount() uint8

func (JapaneseBaseRule) Tiles 

func (rule JapaneseBaseRule) Tiles() []Tile

func (JapaneseBaseRule) Tsumo 

func (rule JapaneseBaseRule) Tsumo(player *Player) error

func (JapaneseBaseRule) WallLastTile 

func (rule JapaneseBaseRule) WallLastTile() Tile

func (JapaneseBaseRule) WallTilesCannotDraw 

func (rule JapaneseBaseRule) WallTilesCannotDraw() uint8

type JapaneseHanChanRule 

type JapaneseHanChanRule struct {
	JapaneseBaseRule
}

func (JapaneseHanChanRule) MaxRound 

func (JapaneseHanChanRule) MaxRound() *Round

type JapaneseTonPuuRule 

type JapaneseTonPuuRule struct {
	JapaneseBaseRule
}

func (JapaneseTonPuuRule) MaxRound 

func (JapaneseTonPuuRule) MaxRound() *Round

type Jun 

type Jun int8

巡

func (Jun) First 

func (n Jun) First() bool

type Mahjong 

type Mahjong struct {
	Round
	Rule
	Players
	Result
	Seed           *rand.Rand
	NextTile       uint8
	Tiles          []Tile
	LastTile       Tile
	LastTilePlayer *Player
	KanCount       uint8
}

func Init 

func Init(rule Rule) *Mahjong

func InitWithSeed 

func InitWithSeed(rule Rule, seed int64) *Mahjong

func (*Mahjong) AnKan 

func (maj *Mahjong) AnKan(player *Player, tileType TileType) error

func (*Mahjong) CanAnKan 

func (maj *Mahjong) CanAnKan(player *Player) ([]TileType, error)

func (*Mahjong) CanChii 

func (maj *Mahjong) CanChii(player *Player) ([]TilesXY, error)

func (*Mahjong) CanDahai 

func (maj *Mahjong) CanDahai(player *Player, tile Tile) (int, error)

func (*Mahjong) CanKaKan 

func (maj *Mahjong) CanKaKan(player *Player) ([]Tile, error)

func (*Mahjong) CanKan 

func (maj *Mahjong) CanKan(player *Player) (TilesXXX, error)

func (*Mahjong) CanNineYaochus 

func (maj *Mahjong) CanNineYaochus(player *Player) error

func (*Mahjong) CanPon 

func (maj *Mahjong) CanPon(player *Player) ([]TilesXX, error)

func (*Mahjong) CanRestart 

func (maj *Mahjong) CanRestart() error

func (*Mahjong) CanRiichi 

func (maj *Mahjong) CanRiichi(player *Player) ([]Tile, error)

func (*Mahjong) CanRon 

func (maj *Mahjong) CanRon(player *Player) ([]Agari, error)

func (*Mahjong) CanTsumo 

func (maj *Mahjong) CanTsumo(player *Player) ([]Agari, error)

func (*Mahjong) Chii 

func (maj *Mahjong) Chii(player *Player, tileA, tileB Tile) error

func (*Mahjong) Dahai 

func (maj *Mahjong) Dahai(player *Player, tile Tile) error

func (*Mahjong) Dice 

func (maj *Mahjong) Dice() int

func (*Mahjong) Dora 

func (maj *Mahjong) Dora() uint8

func (*Mahjong) Draw 

func (maj *Mahjong) Draw(player *Player) (Tile, error)

func (*Mahjong) DrawKan 

func (maj *Mahjong) DrawKan(player *Player) (Tile, error)

func (*Mahjong) Haipai 

func (maj *Mahjong) Haipai()

func (*Mahjong) IsTurn 

func (maj *Mahjong) IsTurn(player *Player) bool

func (*Mahjong) Jun 

func (maj *Mahjong) Jun() Jun

func (*Mahjong) KaKan 

func (maj *Mahjong) KaKan(player *Player, tile Tile) error

func (*Mahjong) Kan 

func (maj *Mahjong) Kan(player *Player) error

func (*Mahjong) NewWinningHandBase 

func (maj *Mahjong) NewWinningHandBase(player, atm *Player, sortedHandTiles []Tile) *WinningHandBase

func (*Mahjong) NineYaochus 

func (maj *Mahjong) NineYaochus(player *Player) error

func (*Mahjong) Output 

func (maj *Mahjong) Output(v ...interface{})

func (*Mahjong) PlayerCan 

func (maj *Mahjong) PlayerCan(player *Player) *PlayerActions

func (*Mahjong) Pon 

func (maj *Mahjong) Pon(player *Player, tileA, tileB Tile) error

todo: rotate & move tiles for fuuro

func (*Mahjong) RemainderTilesAll 

func (maj *Mahjong) RemainderTilesAll() uint8

func (*Mahjong) RemainderTilesCanDraw 

func (maj *Mahjong) RemainderTilesCanDraw() uint8

func (*Mahjong) Restart 

func (maj *Mahjong) Restart() error

func (*Mahjong) Riichi 

func (maj *Mahjong) Riichi(player *Player, tile Tile) error

func (*Mahjong) Ron 

func (maj *Mahjong) Ron(player *Player) error

func (*Mahjong) Shuffle 

func (maj *Mahjong) Shuffle()

func (*Mahjong) Stack 

func (maj *Mahjong) Stack() error

func (*Mahjong) Start 

func (maj *Mahjong) Start() error

func (*Mahjong) Tsumo 

func (maj *Mahjong) Tsumo(player *Player) error

type NoTiles 

type NoTiles struct {
	Tiles []Tile
}

func (NoTiles) Error 

func (err NoTiles) Error() string

type NotTurn 

type NotTurn struct{}

func (NotTurn) Error 

func (err NotTurn) Error() string

type Phase 

type Phase int8
const (
	//Pon or Kan
	Idle Phase = iota

	//Chii or Draw
	AddTile

	//AnKan(keep phase) or Dahai
	RemoveTile

	//Draw(kan)
	AddTileKan
)

func (*Phase) Change 

func (phase *Phase) Change(now Phase)

func (Phase) Check 

func (phase Phase) Check(true ...Phase) error

func (Phase) Name 

func (phase Phase) Name() string

type Player 

type Player struct {
	FieldWind
	Score int
	Phase

	Riichi   Jun
	Tiles    []Tile
	XXXs     []Triplet
	XYZs     []Sequential
	XXXXs    []Quad
	Discards []DiscardTile
	LastDraw Tile
	Through  bool
	// contains filtered or unexported fields
}

func (*Player) Concealed 

func (player *Player) Concealed() bool

func (*Player) GetTileTypeIndexes 

func (player *Player) GetTileTypeIndexes(tileType TileType) []int

func (*Player) GetTilesIndexes 

func (player *Player) GetTilesIndexes(tiles ...Tile) ([]int, error)

func (*Player) HasDiscarded 

func (player *Player) HasDiscarded(tile Tile) bool

func (*Player) IsParent 

func (player *Player) IsParent(round Round) bool

func (*Player) Wind 

func (player *Player) Wind(round Round) FieldWind

type PlayerActions 

type PlayerActions struct {
	Draw         bool
	Dahai        bool
	Chii         bool
	ChiiOption   []TilesXY
	Pon          bool
	PonOption    []TilesXX
	Kan          bool
	KanOption    TilesXXX
	AnKan        bool
	AnKanOption  []TileType
	KaKan        bool
	KaKanOption  []Tile
	Riichi       bool
	RiichiOption []Tile
	Ron          bool
	Tsumo        bool
	NineYaochus  bool
}

type Players 

type Players struct {
	// contains filtered or unexported fields
}

func NewPlayers 

func NewPlayers(n int) Players

func (*Players) Do 

func (players *Players) Do(fn func(players *Player))

func (*Players) FindField 

func (players *Players) FindField(field FieldWind) *Player

func (*Players) FindWind 

func (players *Players) FindWind(wind FieldWind, round Round) *Player

func (*Players) Left 

func (players *Players) Left(player *Player) *Player

func (*Players) Move 

func (players *Players) Move(dice int) *Player

func (*Players) Next 

func (players *Players) Next() *Player

func (*Players) Now 

func (players *Players) Now() *Player

func (*Players) Parent 

func (players *Players) Parent(round Round) *Player

func (*Players) Right 

func (players *Players) Right(player *Player) *Player

func (*Players) Set 

func (players *Players) Set(player *Player)

func (*Players) Start 

func (players *Players) Start() *Player

func (*Players) ToNext 

func (players *Players) ToNext() *Player

func (*Players) Toimen 

func (players *Players) Toimen(player *Player) *Player

type Quad 

type Quad struct {
	TilesXXXX TileType
	Concealed bool
	Jun
}

type Result 

type Result struct {
	ResultType
	// contains filtered or unexported fields
}

func (*Result) AddAgari 

func (result *Result) AddAgari(tsumo bool, player *Player, agari Agari)

func (*Result) AddDraw 

func (result *Result) AddDraw()

func (*Result) Done 

func (result *Result) Done() bool

func (*Result) Init 

func (result *Result) Init()

type ResultData 

type ResultData struct {
	Tsumo bool
	*Player
	Agari
}

type ResultType 

type ResultType int8
const (
	NoResult    ResultType = 0
	AgariResult ResultType = 1
	DrawResult  ResultType = 2
)

type Round 

type Round struct {
	//場
	FieldWind, MaxFieldWind FieldWind

	//局
	Number, MaxNumber int8

	//累計局数
	RealNumber int8

	//本場
	Honba int8
}

func NewRound 

func NewRound(maxField FieldWind, maxNumber int8) *Round

func (*Round) ToNext 

func (round *Round) ToNext(normal bool)

type Rule 

type Rule interface {
	Init(maj *Mahjong)
	PlayersSitDown() Players
	Tiles() []Tile
	MaxRound() *Round
	WallTilesCannotDraw() uint8
	CanRiichi(player *Player) ([]Tile, error)
	Riichi(player *Player, tile Tile) error
	CanRon(player *Player) ([]Agari, error)
	Ron(player *Player) error
	CanTsumo(player *Player) ([]Agari, error)
	Tsumo(player *Player) error
	CanNineYaochus(player *Player) error
	NineYaochus(player *Player) error
	CanAgari(player *Player, last Tile) ([]Agari, error)
}

type ScoreSrc 

type ScoreSrc int

func NewScore 

func NewScore(fu int, fan Fan) ScoreSrc

切り上げ満貫

func (ScoreSrc) Ceil 

func (score ScoreSrc) Ceil() int

func (ScoreSrc) ChildRon 

func (score ScoreSrc) ChildRon() int

func (ScoreSrc) ChildTsumo 

func (score ScoreSrc) ChildTsumo() (int, int)

func (ScoreSrc) ParentRon 

func (score ScoreSrc) ParentRon() int

func (ScoreSrc) ParentTsumo 

func (score ScoreSrc) ParentTsumo() int

type Sequential 

type Sequential struct {
	TilesXYZ
	Concealed bool
}

func FindSequential 

func FindSequential(tiles []Tile) ([]Sequential, error)

func (*Sequential) ToTileType 

func (sequential *Sequential) ToTileType() []TileType

type Suit 

type Suit int8
const (
	DotsSuit Suit = iota
	BambooSuit
	CharacterSuit
)

type Tile 

type Tile struct {
	TileType
	Id int8
}

func FindTriplet 

func FindTriplet(tiles []Tile) ([][]Triplet, []Tile)

func SortTiles 

func SortTiles(tiles []Tile) []Tile

func ToSampleTiles 

func ToSampleTiles(tileTypes []TileType) []Tile

func (Tile) IsRed 

func (tile Tile) IsRed() bool

type TileType 

type TileType int8
const (
	None TileType = iota
	Dots1
	Dots2
	Dots3
	Dots4
	Dots5
	Dots6
	Dots7
	Dots8
	Dots9
	Bamboo1
	Bamboo2
	Bamboo3
	Bamboo4
	Bamboo5
	Bamboo6
	Bamboo7
	Bamboo8
	Bamboo9
	Characters1
	Characters2
	Characters3
	Characters4
	Characters5
	Characters6
	Characters7
	Characters8
	Characters9

	East
	South
	West
	North
	White
	Green
	Red

	PlumBlossom
	Orchid
	Chrysanthemum
	Bamboo
	Spring
	Summer
	Autumn
	Winter
)

func SortTileTypes 

func SortTileTypes(tileTypes []TileType) []TileType

func (TileType) IsActiveWind 

func (tileType TileType) IsActiveWind(w1 FieldWind) bool

func (TileType) IsBamboo 

func (tileType TileType) IsBamboo() bool

func (TileType) IsCharacter 

func (tileType TileType) IsCharacter() bool

func (TileType) IsDots 

func (tileType TileType) IsDots() bool

func (TileType) IsDragon 

func (tileType TileType) IsDragon() bool

func (TileType) IsGreen 

func (tileType TileType) IsGreen() bool

func (TileType) IsHonor 

func (tileType TileType) IsHonor() bool

func (TileType) IsSuit 

func (tileType TileType) IsSuit() bool

func (TileType) IsTerminals 

func (tileType TileType) IsTerminals() bool

func (TileType) IsWind 

func (tileType TileType) IsWind() bool

func (TileType) IsYaochu 

func (tileType TileType) IsYaochu() bool

func (TileType) Number 

func (tileType TileType) Number() int8

func (TileType) SameSuit 

func (tileType TileType) SameSuit(other TileType) bool

func (TileType) Suit 

func (tileType TileType) Suit() Suit

func (TileType) Wind 

func (tileType TileType) Wind() FieldWind

type TilesXX 

type TilesXX [2]Tile

type TilesXXX 

type TilesXXX [3]Tile

type TilesXY 

type TilesXY [2]Tile

type TilesXYZ 

type TilesXYZ [3]Tile

type Triplet 

type Triplet struct {
	TilesXXX
	Concealed bool
}

func (*Triplet) ToTileType 

func (triplet *Triplet) ToTileType() []TileType

type WinningHand 

type WinningHand interface {
	CountFu(bool) int
	// contains filtered or unexported methods
}

type WinningHand13 

type WinningHand13 struct {
	WinningHandBase
	Yaochu TileType
}

国士無双の和了形

type WinningHand7 

type WinningHand7 struct {
	WinningHandBase
	XX [7][2]TileType
}

七対子の和了形

func (*WinningHand7) CountFu 

func (hand *WinningHand7) CountFu(bool) int

type WinningHandBase 

type WinningHandBase struct {
	Rule
	Jun
	LastTile              Tile
	Player                *Player
	Atm                   *Player
	Round                 Round
	SortedTileTypes       []TileType
	SortedHandTiles       []Tile
	RemainderTilesCanDraw uint8
}

和了形

type WinningHandNormal 

type WinningHandNormal struct {
	WinningHandBase
	XX   [2]TileType
	XXXs [][3]TileType
	XYZs [][3]TileType

	Triplets   []Triplet
	Sequential []Sequential
	Quad       []Quad
	Head       TilesXX
}

一般的な和了形

func (*WinningHandNormal) CountFu 

func (hand *WinningHandNormal) CountFu(menZen bool) int

type WrongPhase 

type WrongPhase struct {
	True  []Phase
	Wrong Phase
}

func (WrongPhase) Error 

func (err WrongPhase) Error() string

type Yaku 

type Yaku struct {
	Name    string
	FanFR   Fan
	FanMZ   Fan
	Upgrade []Yaku
	Check   func(WinningHand) bool
}

func FindYaku 

func FindYaku(hand WinningHand) []Yaku

func RealYaku 

func RealYaku(yakuTachi []Yaku, menZen bool) []Yaku

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.