1193戦の東1局0本場(1193配牌)の牌山と配牌の頻度を列挙

README

1193戦東1局0本場(1193配牌)の牌山と配牌の頻度を列挙

yama136hist.csv
  牌山の牌の頻度(縦:牌山の位置、横:牌の種類の出現数)(全ての牌を独立して扱い136種)
  yama[0]...リンシャン牌
  yama[135,134,133,132]...親(東家)の配牌の最初の4枚
  
yama34hist.csv
  牌山の牌の頻度(縦:牌山の位置、横:牌の種類の出現数)(牌の種類ごとにまとめて34種)
  yama[0]...リンシャン牌
  yama[135,134,133,132]...親(東家)の配牌の最初の4枚
  
haipai136hist.csv
  配牌の13枚の家ごとの頻度(縦:家、横:牌の種類の出現数)(全ての牌を独立して扱い136種)
  例えば東家は各局の東家(親)の配牌を合算している
  
haipai34hist.csv
  配牌の13枚の家ごとの頻度(縦:家、横:牌の種類の出現数)(牌の種類ごとにまとめて34種)
  例えば東家は各局の東家(親)の配牌を合算している
 
per4yama136hist.csv
  牌山のうちツモりに使う部分を4つごとにまとめた頻度(縦:yama[mod 4]、横:牌の種類の出現数)(全ての牌を独立して扱い136種)
  (つまり副露(チー・ポン・カン)が全く無い場合に牌山から同じ人が引くだろう牌の種類の頻度)
  (配牌の13*4枚と王牌の14枚は除いて計算)

per4yama136hist.csv
  牌山を4つとびにまとめた頻度(縦:yama[mod 4]、横:牌の種類の出現数)(牌の種類ごとにまとめて34種)
  (つまり副露(チー・ポン・カン)が全く無い場合に牌山から同じ人が引くだろう牌の種類の頻度)
  (配牌の13*4枚と王牌の14枚は除いて計算)

rndhist.csv
  yamaのシャッフルやダイスに使うrndの値の頻度 

haipai136hist.csv

haipai34hist.csv

main.go

package main

import (
	mt "bitbucket.org/neetsdkasu/mersenne_twister_go"
	"bufio"
	"bytes"
	"compress/gzip"
	"crypto/sha512"
	"encoding/base64"
	"encoding/binary"
	"encoding/xml"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
)

var haiDisp = [34]string{
	// "一","二","三","四","五","六","七","八","九",
	"1m", "2m", "3m", "4m", "5m", "6m", "7m", "8m", "9m",

	// "①","②","③","④","⑤","⑥","⑦","⑧","⑨",
	"1p", "2p", "3p", "4p", "5p", "6p", "7p", "8p", "9p",

	// "１","２","３","４","５","６","７","８","９",
	"1s", "2s", "3s", "4s", "5s", "6s", "7s", "8s", "9s",

	// "東","南","西","北","白","發","中",
	"1z", "2z", "3z", "4z", "5z", "6z", "7z",
}

var ieDisp = [4]string{"東家", "南家", "西家", "北家"}

func main() {
	if err := run(); err != nil {
		panic(err)
	}
}

var (
	yama136hist     [136][136]int
	yama34hist      [136][34]int
	haipai136hist   [4][136]int
	haipai34hist    [4][34]int
	per4yama136hist [4][136]int
	per4yama34hist  [4][34]int
	rndhist         [137][136]int
)

var logCount = 0
var targetCount = 0
var kyokuCount = 0
var targetKyoku = 0
var targetLobby = 0

func run() error {

	userHomeDir, err := os.UserHomeDir()
	if err != nil {
		return err
	}
	logDir := filepath.Join(
		userHomeDir,
		"Documents",
		"My Tenhou",
		"log",
	)

	flag.StringVar(&logDir, "log", logDir, "specified mjlog folder")
	flag.IntVar(&targetKyoku, "target", 0, "counting target haipai (0: all haipai) (1: only 1st haipai)")
	flag.IntVar(&targetLobby, "lobby", 0, "target lobby  (0: danisen lobby) (-1: all lobby)")
	flag.Parse()

	println("mjlog folder:", logDir)

	err = filepath.Walk(logDir, walk)
	if err != nil {
		return err
	}

	fmt.Println("mjlog count:", logCount)
	fmt.Println("target mjlog count:", targetCount)
	fmt.Println("kyoku count:", kyokuCount)

	for _, f := range []func() error{
		saveYama136hist,
		saveYama34hist,
		saveHaipai136hist,
		saveHaipai34hist,
		savePer4yama136hist,
		savePer4yama34hist,
		saveRndhist,
	} {
		if err = f(); err != nil {
			return err
		}
	}

	return nil
}

func walk(path string, info os.FileInfo, err error) error {
	if err != nil {
		return err
	}
	if info.IsDir() {
		println(info.Name())
		return nil
	}
	if filepath.Ext(info.Name()) != ".mjlog" {
		return nil
	}
	elems, err := load(path)
	if err != nil {
		return err
	}
	err = read(elems)
	if err != nil {
		return err
	}
	logCount++
	if logCount%50 == 0 {
		println(logCount, "...")
	}
	return nil
}

func load(s string) ([]*xml.StartElement, error) {

	src, err := os.Open(s)
	if err != nil {
		return nil, err
	}
	defer src.Close()

	g, err := gzip.NewReader(src)
	if err != nil {
		return nil, err
	}
	defer g.Close()

	bf := bufio.NewReader(g)

	dec := xml.NewDecoder(bf)

	elems := []*xml.StartElement{}
	for {
		token, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		se, ok := token.(xml.StartElement)
		if !ok {
			continue
		}
		elems = append(elems, &se)
	}

	return elems, nil
}

func read(elems []*xml.StartElement) error {

	var game struct {
		Type  string
		Lobby string
	}
	seedAttr := ""
	for _, e := range elems {
		if e.Name.Local == "SHUFFLE" {
			for _, a := range e.Attr {
				if a.Name.Local == "seed" {
					seedAttr = a.Value
					break
				}
			}
		} else if e.Name.Local == "GO" {
			for _, a := range e.Attr {
				if a.Name.Local == "type" {
					game.Type = a.Value
				} else if a.Name.Local == "lobby" {
					game.Lobby = a.Value
				}
			}
			break
		}
	}

	if targetLobby >= 0 && game.Lobby != fmt.Sprint(targetLobby) {
		return nil
	}

	switch game.Type {
	case "1": // 0b0000_0001 東 喰アリ赤 一般
	case "3": // 0b0000_0011 東 喰断アリ 一般
	case "7": // 0b0000_0111 東 喰断ナシ 一般
	case "9": // 0b0000_1001 南 喰アリ赤 一般
	case "11": // 0b0000_1011 南 喰断アリ 一般
	case "15": // 0b0000_1111 南 喰断ナシ 一般
	case "17": // 0b0001_0001 東サンマ喰赤 一般
		return nil
	case "25": // 0b0001_1001 南サンマ喰赤 一般
		return nil
	case "33": // 0b0010_0001 東 喰アリ赤 特上
	case "35": // 0b0010_0011 東 喰断アリ 特上
	case "39": // 0b0010_0111 東 喰断ナシ 特上
	case "41": // 0b0010_1001 南 喰アリ赤 特上
	case "43": // 0b0010_1011 南 喰断アリ 特上
	case "47": // 0b0010_1111 南 喰断ナシ 特上
	case "49": // 0b0011_0001 東サンマ喰赤 特上
		return nil
	case "57": // 0b0011_1001 南サンマ喰赤 特上
		return nil
	case "129": // 0b1000_0001 東 喰アリ赤 上級
	case "131": // 0b1000_0011 東 喰断アリ 上級
	case "135": // 0b1000_0111 東 喰断ナシ 上級
	case "137": // 0b1000_1001 南 喰アリ赤 上級
	case "139": // 0b1000_1011 南 喰断アリ 上級
	case "143": // 0b1000_1111 南 喰断ナシ 上級
	case "145": // 0b1001_0001 東サンマ喰赤 上級
		return nil
	case "153": // 0b1001_1001 南サンマ喰赤 上級
		return nil
	case "161": // 0b1010_0001 東 喰アリ赤 鳳凰
	case "163": // 0b1010_0011 東 喰断アリ 鳳凰
	case "167": // 0b1010_0111 東 喰断ナシ 鳳凰
	case "169": // 0b1010_1001 南 喰アリ赤 鳳凰
	case "171": // 0b1010_1011 南 喰断アリ 鳳凰
	case "175": // 0b1010_1111 南 喰断ナシ 鳳凰
	case "177": // 0b1011_0001 東サンマ喰赤 鳳凰
		return nil
	case "185": // 0b1011_1001 南サンマ喰赤 鳳凰
		return nil
	default:
		return nil
	}

	b64seed := strings.SplitN(seedAttr, ",", 2)
	if len(b64seed) != 2 {
		// different format paifu?
		return nil
	}
	binSeed, err := base64.StdEncoding.DecodeString(b64seed[1])
	if err != nil {
		// different format paifu?
		return nil
	}

	seed := make([]uint32, len(binSeed)/4)
	err = binary.Read(
		bytes.NewReader(binSeed),
		binary.LittleEndian,
		seed,
	)
	if err != nil {
		return err
	}

	mtLocal := new(mt.MersenneTwister).InitByArray(seed)

	kyoku := 0

	for _, se := range elems {

		if se.Name.Local != "INIT" {
			continue
		}
		kyoku++

		if targetKyoku > 0 && kyoku != targetKyoku {
			if kyoku < targetKyoku {
				for i := 0; i < 64/4*9*2; i++ {
					mtLocal.Uint32()
				}
				continue
			} else {
				break
			}
		} else if targetKyoku < 0 && kyoku+targetKyoku > 0 {
			break
		}

		init := se

		src := make([]uint32, 64/4*9*2)
		for i := range src {
			src[i] = mtLocal.Uint32()
		}
		var binSrcBuf bytes.Buffer
		err = binary.Write(
			&binSrcBuf,
			binary.LittleEndian,
			src,
		)
		if err != nil {
			return err
		}
		binSrc := binSrcBuf.Bytes()

		binRnd := make([]byte, 64*9)
		for i := 0; i < 9; i++ {
			tmp := sha512.Sum512(binSrc[:128])
			copy(binRnd[i*64:], tmp[:])
			binSrc = binSrc[128:]
		}

		rnd := make([]uint32, 64/4*9)
		err = binary.Read(
			bytes.NewReader(binRnd),
			binary.LittleEndian,
			rnd,
		)
		if err != nil {
			return err
		}

		yama := make([]int, 136)
		for i := range yama {
			yama[i] = i
		}

		for i := 0; i < 135; i++ {
			j := i + int(rnd[i]%uint32(136-i))
			yama[i], yama[j] = yama[j], yama[i]
			rndhist[i][j-i]++
		}

		for i, y := range yama {
			yama136hist[i][y]++
			yama34hist[i][y/4]++
		}

		// 扱いやすくするため牌山を逆順に
		for i, j := 0, len(yama)-1; i < j; i, j = i+1, j-1 {
			yama[i], yama[j] = yama[j], yama[i]
		}

		hai := make([]string, 4)
		for i, y := range yama[:12*4] {
			p := (i >> 2) & 3
			hai[p] = fmt.Sprint(hai[p], y, ",")
			haipai136hist[p][y]++
			haipai34hist[p][y/4]++
		}
		for i, y := range yama[12*4 : 13*4] {
			hai[i] = fmt.Sprint(hai[i], y)
			haipai136hist[i][y]++
			haipai34hist[i][y/4]++
		}

		for i, y := range yama[13*4 : 136-14] {
			per4yama136hist[3-(i%4)][y]++
			per4yama34hist[3-(i%4)][y/4]++
		}

		var oya int
		for _, a := range init.Attr {
			if a.Name.Local == "oya" {
				fmt.Sscan(a.Value, &oya)
				break
			}
		}

		for i, h := range hai {
			n := fmt.Sprint("hai", (oya+i)&3)
			for _, a := range init.Attr {
				if a.Name.Local != n {
					continue
				}
				if a.Value != h {
					return fmt.Errorf("not equal %s %q %q %#v %#v", n, a.Value, h, hai, game)
				}
				break
			}
		}

		dice1 := rnd[135] % 6
		dice2 := rnd[136] % 6
		dora := yama[130]

		rndhist[135][dice1]++
		rndhist[136][dice2]++

		rest := fmt.Sprintf(",%d,%d,%d", dice1, dice2, dora)

		for _, a := range init.Attr {
			if a.Name.Local == "seed" {
				if !strings.HasSuffix(a.Value, rest) {
					return fmt.Errorf("unmatch INIT.seed rest %q %q", a.Value, rest)
				}
			}
		}

		kyokuCount++
	}

	if targetKyoku > 0 && kyoku >= targetKyoku {
		targetCount++
	} else if targetKyoku <= 0 {
		targetCount++
	}

	return nil
}

func saveYama136hist() error {
	f, err := os.Create("yama136hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "yama")
	if err != nil {
		return err
	}
	for i := 0; i < 136; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i/4])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, yamai := range yama136hist {
		_, err = fmt.Fprint(f, i)
		if err != nil {
			return err
		}
		for _, c := range yamai {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func saveYama34hist() error {
	f, err := os.Create("yama34hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "yama")
	if err != nil {
		return err
	}
	for i := 0; i < 34; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, yamai := range yama34hist {
		_, err = fmt.Fprint(f, i)
		if err != nil {
			return err
		}
		for _, c := range yamai {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func saveHaipai136hist() error {
	f, err := os.Create("haipai136hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "ie")
	if err != nil {
		return err
	}
	for i := 0; i < 136; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i/4])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, haipaii := range haipai136hist {
		_, err = fmt.Fprint(f, ieDisp[i])
		if err != nil {
			return err
		}
		for _, c := range haipaii {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func saveHaipai34hist() error {
	f, err := os.Create("haipai34hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "ie")
	if err != nil {
		return err
	}
	for i := 0; i < 34; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, haipaii := range haipai34hist {
		_, err = fmt.Fprint(f, ieDisp[i])
		if err != nil {
			return err
		}
		for _, c := range haipaii {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func savePer4yama136hist() error {
	f, err := os.Create("per4yama136hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "yama(mod 4)")
	if err != nil {
		return err
	}
	for i := 0; i < 136; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i/4])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, tsumoi := range per4yama136hist {
		_, err = fmt.Fprint(f, i)
		if err != nil {
			return err
		}
		for _, c := range tsumoi {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func savePer4yama34hist() error {
	f, err := os.Create("per4yama34hist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "yama(mod 4)")
	if err != nil {
		return err
	}
	for i := 0; i < 34; i++ {
		_, err = fmt.Fprint(f, ",", haiDisp[i])
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, tsumoi := range per4yama34hist {
		_, err = fmt.Fprint(f, i)
		if err != nil {
			return err
		}
		for _, c := range tsumoi {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

func saveRndhist() error {
	f, err := os.Create("rndhist.csv")
	if err != nil {
		return err
	}
	defer f.Close()

	_, err = fmt.Fprint(f, "index")
	if err != nil {
		return err
	}
	for i := 0; i < 136; i++ {
		_, err = fmt.Fprint(f, ",", i)
		if err != nil {
			return err
		}
	}
	_, err = fmt.Fprintln(f)
	if err != nil {
		return err
	}

	for i, rndi := range rndhist {
		_, err = fmt.Fprint(f, i)
		if err != nil {
			return err
		}
		for _, c := range rndi {
			_, err = fmt.Fprint(f, ",", c)
			if err != nil {
				return err
			}
		}
		_, err = fmt.Fprintln(f)
		if err != nil {
			return err
		}
	}

	return nil
}

per4yama136hist.csv

per4yama34hist.csv

rndhist.csv

yama136hist.csv

yama34hist.csv