TUI でコードブレイカーを作る

code-breaker/
├── gamestate/
│   └── state.go
├── main.go
└── widget/
    ├── <widget_1>.go
    ├── ...
    └── <widget_n>.go

// ゲーム全体にまつわる状態
type state struct {
	Length     int   // 数列の桁数
	MaxNumber  int   // 使用可能な数字 (1〜MaxNumber)
	IsRevealed bool  // 正解を開示するか否か (正解を見破った or 試行回数を使い切った場合に true)
	Code       []int // 正解
	tryCount   int   // 試行した回数 (上限に達したらチャレンジ終了)
}

// 最大試行回数
const maxTry = 9

// ランダムな正解を生成する。
func (s *state) generateCode() []int {
	code := make([]int, s.MaxNumber)

	for i := range s.MaxNumber {
		code[i] = i + 1
	}

	rand.Shuffle(
		s.MaxNumber,
		func(i, j int) {
			code[i], code[j] = code[j], code[i]
		},
	)

	return code[0:s.Length]
}

var stateInstance *state

// stateインスタンスを初期化する。
func Initialize(length int, maxNumber int) {
	stateInstance = &state{
		Length:    length,
		MaxNumber: maxNumber,
	}

	stateInstance.Reset()
}

// stateインスタンスを取得する。
func GetState() *state {
	return stateInstance
}

// stateインスタンスを初期状態にリセットする。
func (s *state) Reset() {
	s.IsRevealed = false

	s.Code = s.generateCode()

	s.tryCount = 0
}

// 試行回数をカウントアップする。
func (s *state) Try() {
	s.tryCount++

	if maxTry <= s.tryCount {
		s.Reveal()
	}
}

// 正解を開示する。
func (s *state) Reveal() {
	s.IsRevealed = true
}

// リセット可能なウィジェットを表すインタフェイス
type Resettable interface {
	reset()
}

// 解答を受け取って自身の状態を更新するウィジェットを表すインタフェイス
type Updatable interface {
	update(guess []int)
}

// 値を空白で囲む。
func withPadding(a ...any) string {
	return " " + fmt.Sprint(a...) + " "
}

// ゲームのタイトルを表示するヘッダ・ウィジェット
type header struct {
	Section *tview.TextView // tview
}

// headerウィジェットを生成する。
func NewHeader() *header {
	section := tview.NewTextView()

	h := &header{
		Section: section,
	}

	h.Section.
		SetTextAlign(tview.AlignCenter).
		SetText(withPadding("Code Breaker")).
		SetBorder(true)

	return h
}

// プレイヤーの解答を入力するウィジェット
type try struct {
	Section *tview.Form // tview
}

// tryウィジェットを生成する。
func NewTry(widgets []Updatable) *try {
	section := tview.NewForm()

	t := &try{
		Section: section,
	}

	s := gamestate.GetState()

	t.Section.
		... // 後述

	return t
}

func NewTry(widgets []Updatable) *try {
	...

	t.Section.
		AddInputField("Numbers:", "", s.Length+1, func(textToCheck string, lastChar rune) bool {
			if s.Length < len(textToCheck) {
				return false
			}

			if (lastChar < '1') || (rune('0'+s.MaxNumber) < lastChar) {
				return false
			}

			return true
		}, nil)

	...
}

func NewTry(widgets []Updatable) *try {
	...

	t.Section.
		AddInputField("Numbers:", "", s.Length+1, func(textToCheck string, lastChar rune) bool {
			/* 略 */
		}, nil).
		AddButton("OK", func() {
			if s.IsRevealed {
				return
			}

			if len(t.getInputField().GetText()) != s.Length {
				return
			}

			s.Try()

			guess := t.getAnswer()

			for _, w := range widgets {
				w.update(guess)
			}

			t.reset()
		}).
		AddButton("Clear", func() {
			t.reset()
		}).
		SetBorder(true).
		SetTitle(withPadding("Try"))

	...
}

// tryウィジェットを初期化する。
func (t *try) reset() {
	inputField := t.getInputField()

	inputField.SetText("")
}

// 入力フィールドのインスタンスを取得する。
func (t *try) getInputField() *tview.InputField {
	return t.Section.GetFormItemByLabel("Numbers:").(*tview.InputField)
}

// 入力された解答を取得する。
func (t *try) getAnswer() []int {
	var numbers []int

	text := t.getInputField().GetText()

	for _, char := range text {
		digit, _ := strconv.Atoi(string(char))

		numbers = append(numbers, digit)
	}

	return numbers
}

// ゲームのルールを表示するウィジェット
type rule struct {
	Section *tview.TextView // tview
}

// ruleウィジェットを生成する。
func NewRule() *rule {
	section := tview.NewTextView()

	r := &rule{
		Section: section,
	}

	s := gamestate.GetState()

	r.Section.
		SetText(
			withPadding("Length: ", s.Length) + "\n" +
				withPadding("Range: 1-", s.MaxNumber),
		).
		SetBorder(true).
		SetTitle(withPadding("Rule"))

	return r
}

// ゲームのメニューを表示するウィジェット
type menu struct {
	Section *tview.Form // tview
}

// menuウィジェットを生成する。
func NewMenu(app *tview.Application, widgets []Resettable) *menu {
	section := tview.NewForm()

	m := &menu{
		Section: section,
	}

	m.Section.
		AddButton("Reset", func() {
			gamestate.GetState().Reset()

			for _, w := range widgets {
				w.reset()
			}
		}).
		AddButton("Quit", func() {
			app.Stop()
		}).
		SetBorder(true).
		SetTitle(withPadding("Menu"))

	return m
}

// これまでの解答を表示するウィジェット
type answer struct {
	Section *tview.Table // tview
	history [][]int      // 解答履歴
}

// answerウィジェットを生成する。
func NewAnswer() *answer {
	section := tview.NewTable()

	a := &answer{
		Section: section,
	}

	a.Section.
		SetBorders(true).
		SetBorder(true).
		SetTitle(withPadding("Answer"))

	a.reset()

	return a
}

// answerウィジェットを初期化する。
func (a *answer) reset() {
	a.history = [][]int{}

	a.render()
}

// これまでの解答を表示する。
// 正解を見破った場合は正解も表示する。
func (a *answer) render() {
	s := gamestate.GetState()

	a.Section.Clear()

	a.Section.SetCell(0, 0, tview.NewTableCell(withPadding("")))

	for c := range s.Length {
		a.Section.SetCell(0, c+1,
			tview.NewTableCell(withPadding("#", c+1)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignCenter),
		)
	}

	tries := len(a.history)

	for r := range tries {
		a.Section.SetCell(r+1, 0,
			tview.NewTableCell(withPadding("@", r+1)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignLeft),
		)

		for c := range s.Length {
			a.Section.SetCell(r+1, c+1,
				tview.NewTableCell(withPadding(a.history[r][c])).
					SetTextColor(tcell.ColorWhite).
					SetAlign(tview.AlignRight),
			)
		}
	}

	a.Section.SetCell(tries+1, 0,
		tview.NewTableCell(withPadding("Answer")).
			SetTextColor(tcell.ColorBlue).
			SetAlign(tview.AlignLeft),
	)

	for c := range s.Length {
		symbol := "?"

		if s.IsRevealed {
			symbol = fmt.Sprint(s.Code[c])
		}

		cell := tview.NewTableCell(withPadding(symbol)).
			SetTextColor(tcell.ColorLightGreen).
			SetAlign(tview.AlignRight)

		if s.IsRevealed {
			cell.SetAttributes(tcell.AttrBlink)
		}

		a.Section.SetCell(tries+1, c+1, cell)
	}
}

// 新たな解答を受け取り、履歴に追加する。
func (a *answer) update(guess []int) {
	s := gamestate.GetState()

	a.history = append(a.history, guess)

	if reflect.DeepEqual(guess, s.Code) {
		s.Reveal()
	}

	a.render()
}

// これまでのヒット数とブロー数を表示するウィジェット
type judge struct {
	Section *tview.Table // tview
	history [][]int      // ヒット数とブロー数の履歴
}

// judgeウィジェットを生成する。
func NewJudge() *judge {
	section := tview.NewTable()

	j := &judge{
		Section: section,
	}

	j.Section.
		SetBorders(true).
		SetBorder(true).
		SetTitle(withPadding("Judge"))

	j.reset()

	return j
}

// judgeウィジェットを初期化する。
func (j *judge) reset() {
	j.history = [][]int{}

	j.render()
}

// これまでのヒット数とブロー数を表示する。
func (j *judge) render() {
	j.Section.Clear()

	j.Section.SetCell(0, 0, tview.NewTableCell(withPadding("  ")))

	for c, v := range []string{"Hit", "Blow"} {
		j.Section.SetCell(0, c+1,
			tview.NewTableCell(withPadding(v)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignCenter),
		)
	}

	tries := len(j.history)

	for r := range tries {
		j.Section.SetCell(r+1, 0,
			tview.NewTableCell(withPadding("@", r+1)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignLeft),
		)

		for c, v := range j.history[r] {
			j.Section.SetCell(r+1, c+1,
				tview.NewTableCell(withPadding(v)).
					SetTextColor(tcell.ColorWhite).
					SetAlign(tview.AlignRight),
			)
		}
	}
}

// 新たな解答を受け取り、ヒット数とブロー数を算出して履歴に追加する。
func (j *judge) update(guess []int) {
	hit, blow := hitAndBlow(guess, gamestate.GetState().Code)

	j.history = append(j.history, []int{hit, blow})

	j.render()
}

// ヒット数とブロー数を算出する。
func hitAndBlow(guess []int, code []int) (int, int) {
	hit := 0
	blow := 0

	digitMap := map[int]int{}

	for i, v := range code {
		digitMap[v] = i
	}

	for i, v := range guess {
		if pos, ok := digitMap[v]; ok {
			if i == pos {
				hit++
			} else {
				blow++
			}
		}
	}

	return hit, blow
}

// ヒントの凡例
const (
	symbolHit           = '@' // ヒット
	symbolExist         = 'O' // 正解には当該数字が含まれる
	symbolExcluded      = 'X' // 正解には当該数字が含まれない
	symbolNotDetermined = ' ' // 未確定 (= 情報が足りず、判断できない)
)

// これまでの試行から得られた情報をヒントとして表示するウィジェット
type hint struct {
	Section    *tview.Table // tview
	matrix     [][]rune     // ヒント表
	candidates [][]int      // これまでの結果に合致する、正解の候補群 (ヒントの導出に使用する)
}

// hintウィジェットを生成する。
func NewHint() *hint {
	section := tview.NewTable()

	h := &hint{
		Section: section,
	}

	h.Section.
		SetBorders(true).
		SetBorder(true).
		SetTitle(withPadding("Hint"))

	h.reset()

	return h
}

// hintウィジェットを初期化する。
func (h *hint) reset() {
	h.initializeCandidates()

	h.initializeMatrix()

	h.render()
}

// 正解候補群に初期値 (= 使用可能な数字から成る順列) をセットする。
func (h *hint) initializeCandidates() {
	s := gamestate.GetState()

	digits := make([]int, s.MaxNumber)

	for i := range digits {
		digits[i] = i + 1
	}

	h.candidates = h.generatePermutations([]int{}, digits)
}

// 正解の候補となる順列を生成する。
func (h *hint) generatePermutations(permutation []int, rest []int) [][]int {
	result := [][]int{}

	s := gamestate.GetState()

	if len(permutation) == s.Length {
		candidate := make([]int, len(permutation))

		copy(candidate, permutation)

		return append(result, candidate)
	}

	for i, v := range rest {
		result = slices.Concat(
			result,
			h.generatePermutations(
				append(permutation, v),
				slices.Concat(rest[:i], rest[i+1:]),
			),
		)
	}

	return result
}

// ヒント表に初期値 (= すべてのマスが未確定) をセットする。
func (h *hint) initializeMatrix() {
	s := gamestate.GetState()

	matrix := make([][]rune, s.MaxNumber)

	for r := range s.MaxNumber {
		matrix[r] = make([]rune, s.Length)

		for c := range s.Length {
			matrix[r][c] = symbolNotDetermined
		}
	}

	h.matrix = matrix
}

// ヒントを表示する。
func (h *hint) render() {
	s := gamestate.GetState()

	h.Section.Clear()

	h.Section.SetCell(0, 0, tview.NewTableCell(withPadding("")))

	for c := range s.Length {
		h.Section.SetCell(0, c+1,
			tview.NewTableCell(withPadding("#", c+1)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignCenter),
		)
	}

	for r := range s.MaxNumber {
		h.Section.SetCell(r+1, 0,
			tview.NewTableCell(withPadding(r+1)).
				SetTextColor(tcell.ColorBlue).
				SetAlign(tview.AlignLeft),
		)

		for c := range s.Length {
			cellValue := h.matrix[r][c]

			cell := tview.NewTableCell(withPadding(string(cellValue))).
				SetAlign(tview.AlignRight)

			switch cellValue {
			case symbolHit:
				cell.SetTextColor(tcell.ColorLightGreen)
			case symbolExist:
				cell.SetTextColor(tcell.ColorYellow)
			case symbolExcluded:
				cell.SetTextColor(tcell.ColorRed)
			default:
				cell.SetTextColor(tcell.ColorWhite)
			}

			h.Section.SetCell(r+1, c+1, cell)
		}
	}
}

// 新たな解答とその判定結果を受け取り、ヒントを更新する。
func (h *hint) update(guess []int) {
	h.updateCandidates(guess)

	h.updateMatrix()

	h.render()
}

// 正解候補群を更新する。
// (受け取った解答と判定結果に合致する候補のみを残す。)
func (h *hint) updateCandidates(guess []int) {
	newCandidates := [][]int{}

	hitA, blowA := hitAndBlow(guess, gamestate.GetState().Code)

	for _, candidate := range h.candidates {
		hitB, blowB := hitAndBlow(guess, candidate)

		if hitA == hitB && blowA == blowB {
			newCandidates = append(newCandidates, candidate)
		}
	}

	h.candidates = newCandidates
}

// ヒント表を更新する。
func (h *hint) updateMatrix() {
	s := gamestate.GetState()

	digitPossibilities := make([]map[int]struct{}, s.Length)

	for i := range s.Length {
		digitPossibilities[i] = map[int]struct{}{}
	}

	exists := 0

	for i := range s.MaxNumber {
		exists = exists + (1 << i)
	}

	for _, candidate := range h.candidates {
		bits := 0

		for i, v := range candidate {
			digitPossibilities[i][v] = struct{}{}

			bits = bits + (1 << (v - 1))
		}

		exists = exists & bits
	}

	for c, possibility := range digitPossibilities {
		possibles := []int{}

		for r := range s.MaxNumber {
			if _, ok := possibility[r+1]; ok {
				possibles = append(possibles, r)
			} else {
				// ルール1: 当該桁において候補に含まれない数字は、正解から除外できる。
				h.matrix[r][c] = symbolExcluded
			}
		}

		if len(possibles) == 1 {
			// ルール2: 当該桁において候補数が唯一つの数字は、ヒットであることが確定する。
			h.matrix[possibles[0]][c] = symbolHit
		}
	}

	for v := range s.MaxNumber {
		if exists&(1<<v) != 0 {
			for c := range s.Length {
				if h.matrix[v][c] == symbolNotDetermined {
					// ルール3: 正解候補群のすべてに含まれる数字は、正解のいずれかの桁に存在する。
					h.matrix[v][c] = symbolExist
				}
			}
		}
	}
}

func main() {
	if err := run(); err != nil {
		fmt.Println(err)

		os.Exit(1)
	} else {
		os.Exit(0)
	}
}

// ゲームを開始する。
func run() error {
	length, maxNumber, err := parseFlags()

	if err != nil {
		return err
	}

	app := tview.NewApplication()

	gamestate.Initialize(length, maxNumber)

	header := widget.NewHeader()

	rule := widget.NewRule()

	answer := widget.NewAnswer()

	judge := widget.NewJudge()

	hint := widget.NewHint()

	try := widget.NewTry([]widget.Updatable{answer, judge, hint})

	menu := widget.NewMenu(app, []widget.Resettable{try, answer, judge, hint})

	root := tview.NewFlex().
		SetDirection(tview.FlexRow).
		AddItem(header.Section, 3, 0, false).
		AddItem(
			tview.NewFlex().
				AddItem(try.Section, 0, 4, true).
				AddItem(rule.Section, 0, 3, false).
				AddItem(menu.Section, 0, 3, false),
			7, 0, true,
		).
		AddItem(
			tview.NewFlex().
				AddItem(answer.Section, 0, 2, false).
				AddItem(judge.Section, 0, 1, false).
				AddItem(hint.Section, 0, 2, false),
			0, 1, false,
		)

	app.
		SetRoot(root, true).
		SetFocus(root).
		EnableMouse(true)

	if err := app.Run(); err != nil {
		return err
	}

	return nil
}

// コマンドライン引数をパースする。
func parseFlags() (int, int, error) {
	length := flag.Int("l", 3, "Number of digits. [1-9]")
	maxNumber := flag.Int("n", 5, "Maximum number to be used, ranging from 1 up to this value. [1-9]")

	flag.Parse()

	if (*length < 1) || (9 < *length) {
		return 0, 0, fmt.Errorf("number of digits must be between 1 and 9")
	}

	if (*maxNumber < 1) || (9 < *maxNumber) {
		return 0, 0, fmt.Errorf("maximum number must be between 1 and 9")
	}

	if *maxNumber < *length {
		return 0, 0, fmt.Errorf("number of digits must be less than or equal to maximum number")
	}

	return *length, *maxNumber, nil
}