【アプリ】PictureNumbering 画像連番刻印（印刷）アプリ【Vector】

PictureNumberingというアプリを作りました

登録した画像に順番に連番を刻印するアプリです



Vectorにて公開しています
www.vector.co.jp
■1.ソフトの概要
複数の画像に連番を刻印するアプリです

■2.作者への連絡先
gngmp391@ybb.ne.jp

■3.取り扱い種別
本ソフトはフリーソフトです

■4.動作環境
Microsoft .Net Framework 4.7.2

■5.インストール・アンインストール方法
〇インストール
任意の場所に解凍してEXEファイルを実行
〇アンインストール
EXEファイルや説明ファイルを削除

◆説明動画
https://youtu.be/YQWfPlmaJR0
動画からffmpegを使用して連番を刻印して動画GIFを作成しています
なおffmpegの細かい設定については取り扱いません

====================================
ffmpegなどで動画を画像にして連番を振るのに便利です
例えば格闘対戦ゲームなどでフレームを表示するなどに向いています

====================================
また画像の大きさがバラバラでも対応しています

====================================
ファイルの登録はエクスプローラーからのドラッグアンドドロップとコピーペーストと
ファイルのテキストリストのクリップボードペーストに対応しています

ファイルテキストリストとはPowerShellの場合は
>ls *.png | %{echo $_.fullname}
または
>ls *.png | %{echo $_.fullname} > filelist.txt
などで得られるテキストのリストのクリップボードコピーです

====================================
ナンバリングの刻印は
左上・中央上・右上
左中央・中央・右中央
左下・中央下・右下
の何れかから選び
上下余白と左右余白を指定します

====================================
画像に刻印する連番は前ゼロを指定することができます
またフォントを等幅フォントにすると出来栄えが良く見えます

====================================
使用することができる画像ファイルの種類は
.Net Frameworkで扱える画像ファイル種です

ビットマップ .bmp 非圧縮形式
JPEG .jpg .jpeg 写真向け、圧縮あり
GIF .gif アニメーション GIF は静止画として表示
PNG .png 透過対応
TIFF .tif .tiff 複数ページ TIFF は最初のページのみ表示
アイコン .ico アイコン形式
です

適応可能なファイル以外はリストに登録されません

====================================
基本的に画像ファイルを上書きすることは想定していませんので
必ず「ファイル前置詞」をつけるか「保存フォルダ」は空のものを指定してください
「ファイル前置詞番号」を利用するとファイル名は基本的にユニークになります
この番号は1から順番に「番号桁数」に応じて前ゼロ付きで付与されます
番号桁数が変換画像数に足りるように設定してください
足りない場合は指定した桁数で循環するので注意(ユニークでなくなる場合がある)が必要です

====================================
エクスプローラーからのドラッグアンドドロップで一括登録の場合は稀にファイルの順番が変わることがあるのでリストを確認して登録しなおすかソート機能があるのでそれを使用してください

====================================
■変更履歴
2026/03/11 Vectorに発登録 Ver 1.0.0.0
2026/03/26 細かい修正点と説明動画の告知 Ver 1.1.1.1

【Windows】AutoHotKey v2を使ってJones式発音記号(アクセント)を入力する【英語】

AutoHotKeyを使えばJones式発音記号を比較的に楽に入力することができます

以下のURLからAutoHotKeyをインストールします
https://www.autohotkey.com/

ダウンロードしたインストールファイルを実行します
インストールしたらWindowsを再起動してください

ahkファイルを作る

適当な名前(AutoHotKey_jones.ahkなど)を付けてahkファイルとして新規作成してください
ファイルの文字コードをUTF-8にしてください

以下のコードをahkファイルに張り付けてください

#^!j:: {
    main := Menu()

    ; ===== 母音（短母音）=====
    shortV := Menu()
    shortV.Add("ɪ  (sit)", (*) => SendText("ɪ"))
    shortV.Add("e  (bed)", (*) => SendText("e"))
    shortV.Add("æ  (cat)", (*) => SendText("æ"))
    shortV.Add("ɒ  (lot BrE)", (*) => SendText("ɒ"))
    shortV.Add("ʌ  (cup)", (*) => SendText("ʌ"))
    shortV.Add("ʊ  (put)", (*) => SendText("ʊ"))
    shortV.Add("ə  (about)", (*) => SendText("ə"))
    main.Add("母音（短母音）", shortV)

    ; ===== 母音（長母音）=====
    longV := Menu()
    longV.Add("iː (see)", (*) => SendText("iː"))
    longV.Add("ɑː (father)", (*) => SendText("ɑː"))
    longV.Add("ɔː (law)", (*) => SendText("ɔː"))
    longV.Add("ɜː (nurse)", (*) => SendText("ɜː"))
    longV.Add("uː (goose)", (*) => SendText("uː"))
    main.Add("母音（長母音）", longV)

    ; ===== 二重母音 =====
    dip := Menu()
    dip.Add("eɪ (face)", (*) => SendText("eɪ"))
    dip.Add("aɪ (price)", (*) => SendText("aɪ"))
    dip.Add("ɔɪ (choice)", (*) => SendText("ɔɪ"))
    dip.Add("aʊ (mouth)", (*) => SendText("aʊ"))
    dip.Add("əʊ (goat BrE)", (*) => SendText("əʊ"))
    dip.Add("ɪə (near)", (*) => SendText("ɪə"))
    dip.Add("eə (square)", (*) => SendText("eə"))
    dip.Add("ʊə (cure)", (*) => SendText("ʊə"))
    main.Add("二重母音", dip)

    ; ===== 破裂音 =====
    plosive := Menu()
    plosive.Add("p", (*) => SendText("p"))
    plosive.Add("b", (*) => SendText("b"))
    plosive.Add("t", (*) => SendText("t"))
    plosive.Add("d", (*) => SendText("d"))
    plosive.Add("k", (*) => SendText("k"))
    plosive.Add("g", (*) => SendText("g"))
    main.Add("破裂音", plosive)

    ; ===== 摩擦音 =====
    fric := Menu()
    fric.Add("f", (*) => SendText("f"))
    fric.Add("v", (*) => SendText("v"))
    fric.Add("θ (thin)", (*) => SendText("θ"))
    fric.Add("ð (this)", (*) => SendText("ð"))
    fric.Add("s", (*) => SendText("s"))
    fric.Add("z", (*) => SendText("z"))
    fric.Add("ʃ (ship)", (*) => SendText("ʃ"))
    fric.Add("ʒ (vision)", (*) => SendText("ʒ"))
    fric.Add("h", (*) => SendText("h"))
    main.Add("摩擦音", fric)

    ; ===== 破擦音 =====
    aff := Menu()
    aff.Add("tʃ (church)", (*) => SendText("tʃ"))
    aff.Add("dʒ (judge)", (*) => SendText("dʒ"))
    main.Add("破擦音", aff)

    ; ===== 鼻音 =====
    nasal := Menu()
    nasal.Add("m", (*) => SendText("m"))
    nasal.Add("n", (*) => SendText("n"))
    nasal.Add("ŋ (sing)", (*) => SendText("ŋ"))
    main.Add("鼻音", nasal)

    ; ===== 側音・接近音 =====
    appr := Menu()
    appr.Add("l", (*) => SendText("l"))
    appr.Add("r", (*) => SendText("r"))
    appr.Add("j (yes)", (*) => SendText("j"))
    appr.Add("w", (*) => SendText("w"))
    main.Add("側音・接近音", appr)

    ; ===== アクセント・補助記号 =====
    supr := Menu()
    supr.Add("ˈ 主強勢", (*) => SendText("ˈ"))
    supr.Add("ˌ 副強勢", (*) => SendText("ˌ"))
    supr.Add("ː 長音", (*) => SendText("ː"))
    main.Add("アクセント・補助記号", supr)

    main.Show()
}

メモ帳などテキストエディタなどを開いてWin+Ctrl+Alt+jキーを押すと発音記号を選択できるメニューが出ます
メニューから発音記号を選択するとテキストエディタに発音記号が入力できます

Windowsのスタートアップに登録

必須ではありませんがスタートアップに登録することでWindows起動時にahkスクリプトを起動することができます
C:\Users\{ユーザー名}\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
に作成したahkファイルのショートカットを配置します

なお、AutoHotKeyはタスクトレイに常駐し、以下のメニューを選択して実行することができます

ahkファイルのプログラム登録

ahkファイルをAutoHotKeyプログラムで開くに登録するとダブルクリックでスクリプトを実行できるようになります
方法はahkファイルを右クリックしてファイルのプロパティを開きます
「全般」タブのプログラムの「変更」ボタンを押して「.ahk ファイルの既定のプログラムを選択する」メニューから下方にある「PCでアプリを選択する」を選択します
「プログラムから開く」ダイアログが出ますので
C:\Program Files\AutoHotkey\v2\AutoHotkey64.exe
を指定します

これでahkファイルをダブルクリックするだけでスクリプトが実行されるようになります

IPA式発音記号のahkスクリプトはこちら

Win+Alt+Ctrl+iキーで使えます

#^!i:: {
    main := Menu()

    ; ===== 母音（前舌・中舌・後舌）=====
    vowel := Menu()
    vowel.Add("i  高前舌・非円唇", (*) => SendText("i"))
    vowel.Add("ɪ  前舌・やや低", (*) => SendText("ɪ"))
    vowel.Add("e", (*) => SendText("e"))
    vowel.Add("ɛ", (*) => SendText("ɛ"))
    vowel.Add("æ", (*) => SendText("æ"))

    vowel.Add("ə  中央・曖昧母音", (*) => SendText("ə"))
    vowel.Add("ɜ", (*) => SendText("ɜ"))
    vowel.Add("ɐ", (*) => SendText("ɐ"))

    vowel.Add("ɑ  低後舌", (*) => SendText("ɑ"))
    vowel.Add("ɒ  後舌・円唇", (*) => SendText("ɒ"))
    vowel.Add("ɔ", (*) => SendText("ɔ"))
    vowel.Add("ʊ", (*) => SendText("ʊ"))
    vowel.Add("u", (*) => SendText("u"))

    main.Add("母音", vowel)

    ; ===== 二重母音 =====
    dip := Menu()
    dip.Add("eɪ", (*) => SendText("eɪ"))
    dip.Add("aɪ", (*) => SendText("aɪ"))
    dip.Add("ɔɪ", (*) => SendText("ɔɪ"))
    dip.Add("aʊ", (*) => SendText("aʊ"))
    dip.Add("oʊ", (*) => SendText("oʊ"))
    dip.Add("ɪə", (*) => SendText("ɪə"))
    dip.Add("eə", (*) => SendText("eə"))
    dip.Add("ʊə", (*) => SendText("ʊə"))

    main.Add("二重母音", dip)

    ; ===== 破裂音（Plosives）=====
    plosive := Menu()
    plosive.Add("p", (*) => SendText("p"))
    plosive.Add("b", (*) => SendText("b"))
    plosive.Add("t", (*) => SendText("t"))
    plosive.Add("d", (*) => SendText("d"))
    plosive.Add("k", (*) => SendText("k"))
    plosive.Add("g", (*) => SendText("g"))
    main.Add("破裂音", plosive)

    ; ===== 摩擦音（Fricatives）=====
    fric := Menu()
    fric.Add("f", (*) => SendText("f"))
    fric.Add("v", (*) => SendText("v"))
    fric.Add("θ", (*) => SendText("θ"))
    fric.Add("ð", (*) => SendText("ð"))
    fric.Add("s", (*) => SendText("s"))
    fric.Add("z", (*) => SendText("z"))
    fric.Add("ʃ", (*) => SendText("ʃ"))
    fric.Add("ʒ", (*) => SendText("ʒ"))
    fric.Add("h", (*) => SendText("h"))
    main.Add("摩擦音", fric)

    ; ===== 破擦音（Affricates）=====
    aff := Menu()
    aff.Add("tʃ", (*) => SendText("tʃ"))
    aff.Add("dʒ", (*) => SendText("dʒ"))
    main.Add("破擦音", aff)

    ; ===== 鼻音（Nasals）=====
    nasal := Menu()
    nasal.Add("m", (*) => SendText("m"))
    nasal.Add("n", (*) => SendText("n"))
    nasal.Add("ŋ", (*) => SendText("ŋ"))
    main.Add("鼻音", nasal)

    ; ===== 接近音・側音 =====
    appr := Menu()
    appr.Add("l", (*) => SendText("l"))
    appr.Add("ɹ", (*) => SendText("ɹ"))
    appr.Add("j", (*) => SendText("j"))
    appr.Add("w", (*) => SendText("w"))
    main.Add("接近音・側音", appr)

    ; ===== 超分節音・補助記号 =====
    supr := Menu()
    supr.Add("ˈ 主強勢", (*) => SendText("ˈ"))
    supr.Add("ˌ 副強勢", (*) => SendText("ˌ"))
    supr.Add("ː 長音", (*) => SendText("ː"))
    supr.Add("̃ 鼻音化", (*) => SendText("̃"))
    supr.Add("ʔ 声門閉鎖音", (*) => SendText("ʔ"))
    main.Add("補助記号", supr)

    main.Show()
}

【Rust】麻雀ゲーム作ってみる 設定画面編【その１１】

麻雀のルールの設定画面を作りました

10日ほどかかりました

use crossterm::{
    cursor::{MoveTo, Show, Hide},
    event::{self, Event, KeyCode, KeyEventKind, KeyModifiers},
    execute, queue, style::{Color, Print, SetBackgroundColor, ResetColor},
    terminal::{Clear, ClearType, disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
};
use std::io::{self, stdout, Write};

#[derive(Clone, Copy, PartialEq, Debug)]
enum FocusPosition {
    Button(usize, usize), // ボタン (row, col)
    Input(usize),        // 入力フィールド (row)
}

struct ButtonGrid {
    buttons: Vec<Vec<bool>>,               // 可変長のボタン配列
    current_pos: FocusPosition,            // 現在のフォーカス位置
    last_pos: FocusPosition,               // 前回のフォーカス位置（差分描画用）
    last_selected: Vec<Vec<bool>>,         // 前回の選択状態（差分描画用）
    input_buffer: String,                  // 入力された文字列（行3）
    input_buffer2: String,                 // 入力された文字列（行4）
    last_input_buffer: String,             // 前回の入力内容（差分描画用、行3）
    last_input_buffer2: String,            // 前回の入力内容（差分描画用、行4）
    labels: [&'static str; 10],            // 各行のラベル
    button_labels: Vec<Vec<&'static str>>, // 各行のボタンラベル
}

impl ButtonGrid {
    fn new() -> Self {
        let mut buttons = vec![
            vec![false; 2], // モード
            vec![false; 4], // 局数
            vec![false; 5], // 長考時間
            vec![],         // 配給原点（入力）
            vec![],         // 1位必要点数（入力）
            vec![false; 2], // 飛び
            vec![false; 3], // 赤ドラ
            vec![false; 2], // 喰い断
            vec![false; 3], // 飜縛り
            vec![false; 2], // 手牌表示
        ];

        // 初期選択状態を設定
        buttons[0][0] = true; // モード: 四人麻雀
        buttons[1][2] = true; // 局数: 半荘戦
        buttons[2][2] = true; // 長考時間: 5+20秒
        buttons[5][1] = true; // 飛び: 有効
        buttons[6][1] = true; // 赤ドラ: 赤ドラ3
        buttons[7][1] = true; // 喰い断: 有効
        buttons[8][0] = true; // 飜縛り: 一飜縛り
        buttons[9][0] = true; // 手牌表示: 無効

        ButtonGrid {
            buttons: buttons.clone(),
            current_pos: FocusPosition::Button(0, 0),
            last_pos: FocusPosition::Button(0, 0),
            last_selected: buttons,
            input_buffer: String::from("250"),
            last_input_buffer: String::from("250"),
            input_buffer2: String::from("300"),
            last_input_buffer2: String::from("300"),
            labels: [
                "モード",
                "局数",
                "長考時間",
                "配給原点",
                "1位必要点数",
                "飛び",
                "赤ドラ",
                "喰い断",
                "飜縛り",
                "手牌表示",
            ],
            button_labels: vec![
                vec!["四人麻雀", "三人麻雀"],           // 1行目
                vec!["一局戦", "東風戦", "半荘戦", "CPU戦"], // 2行目
                vec!["3+5秒", "5+10秒", "5+20秒", "60+0秒", "300+0秒"], // 3行目
                vec![],                                 // 4行目（入力）
                vec![],                                 // 5行目（入力）
                vec!["無効", "有効"],                    // 6行目
                vec!["赤無し", "赤ドラ3", "赤ドラ4"],    // 7行目
                vec!["無効", "有効"],                    // 8行目
                vec!["一飜縛り", "二翻縛り", "四翻縛り"], // 9行目
                vec!["無効", "有効"],                    // 10行目
            ],
        }
    }

    // ボタンの選択をトグル（同一行で1つだけ選択）
    fn toggle(&mut self, row: usize, col: usize) {
        for c in 0..self.buttons[row].len() {
            self.buttons[row][c] = false;
        }
        self.buttons[row][col] = true;
    }

    // 次のフォーカスに移動
    fn move_next(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if col < self.buttons[row].len() - 1 {
                    self.current_pos = FocusPosition::Button(row, col + 1);
                } else if row < 2 {
                    self.current_pos = FocusPosition::Button(row + 1, 0);
                } else if row == 2 {
                    self.current_pos = FocusPosition::Input(3);
                } else if row < self.buttons.len() - 1 {
                    self.current_pos = FocusPosition::Button(row + 1, 0);
                } else {
                    self.current_pos = FocusPosition::Button(0, 0);
                }
            }
            FocusPosition::Input(row) => {
                if row == 3 {
                    self.current_pos = FocusPosition::Input(4);
                } else if row == 4 {
                    self.current_pos = FocusPosition::Button(5, 0);
                }
            }
        }
    }

    // 前のフォーカスに移動
    fn move_prev(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if col > 0 {
                    self.current_pos = FocusPosition::Button(row, col - 1);
                } else if row == 0 {
                    self.current_pos = FocusPosition::Button(self.buttons.len() - 1, self.buttons[self.buttons.len() - 1].len() - 1);
                } else if row == 5 {
                    self.current_pos = FocusPosition::Input(4);
                } else {
                    self.current_pos = FocusPosition::Button(row - 1, self.buttons[row - 1].len() - 1);
                }
            }
            FocusPosition::Input(row) => {
                if row == 4 {
                    self.current_pos = FocusPosition::Input(3);
                } else if row == 3 {
                    self.current_pos = FocusPosition::Button(2, self.buttons[2].len() - 1);
                }
            }
        }
    }

    // 上に移動
    fn move_up(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if row == 0 {
                    let target_row = self.buttons.len() - 1;
                    let target_col = col.min(self.buttons[target_row].len() - 1);
                    self.current_pos = FocusPosition::Button(target_row, target_col);
                } else if row == 5 {
                    self.current_pos = FocusPosition::Input(4);
                } else if row > 0 {
                    let target_row = if row <= 2 { row - 1 } else { row - 1 };
                    let target_col = col.min(self.buttons[target_row].len() - 1);
                    if target_row == 3 || target_row == 4 {
                        self.current_pos = FocusPosition::Input(target_row);
                    } else {
                        self.current_pos = FocusPosition::Button(target_row, target_col);
                    }
                }
            }
            FocusPosition::Input(row) => {
                if row == 4 {
                    self.current_pos = FocusPosition::Input(3);
                } else if row == 3 {
                    self.current_pos = FocusPosition::Button(2, 0);
                }
            }
        }
    }

    // 下に移動
    fn move_down(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if row < 2 {
                    let target_row = row + 1;
                    let target_col = col.min(self.buttons[target_row].len() - 1);
                    self.current_pos = FocusPosition::Button(target_row, target_col);
                } else if row == 2 {
                    self.current_pos = FocusPosition::Input(3);
                } else if row < self.buttons.len() - 1 {
                    let target_row = row + 1;
                    let target_col = col.min(self.buttons[target_row].len() - 1);
                    if target_row == 3 || target_row == 4 {
                        self.current_pos = FocusPosition::Input(target_row);
                    } else {
                        self.current_pos = FocusPosition::Button(target_row, target_col);
                    }
                } else {
                    let target_col = col.min(self.buttons[0].len() - 1);
                    self.current_pos = FocusPosition::Button(0, target_col);
                }
            }
            FocusPosition::Input(row) => {
                if row == 3 {
                    self.current_pos = FocusPosition::Input(4);
                } else if row == 4 {
                    self.current_pos = FocusPosition::Button(5, 0);
                }
            }
        }
    }

    // 左に移動
    fn move_left(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if col > 0 {
                    self.current_pos = FocusPosition::Button(row, col - 1);
                } else {
                    self.current_pos = FocusPosition::Button(row, self.buttons[row].len() - 1);
                }
            }
            FocusPosition::Input(row) => {
                if row == 3 {
                    self.current_pos = FocusPosition::Button(2, self.buttons[2].len() - 1);
                } else if row == 4 {
                    self.current_pos = FocusPosition::Input(3);
                }
            }
        }
    }

    // 右に移動
    fn move_right(&mut self) {
        match self.current_pos {
            FocusPosition::Button(row, col) => {
                if col < self.buttons[row].len() - 1 {
                    self.current_pos = FocusPosition::Button(row, col + 1);
                } else {
                    self.current_pos = FocusPosition::Button(row, 0);
                }
            }
            FocusPosition::Input(row) => {
                if row == 3 {
                    self.current_pos = FocusPosition::Input(4);
                } else if row == 4 {
                    self.current_pos = FocusPosition::Button(5, 0);
                }
            }
        }
    }

    // 選択されているボタンのラベルを取得
    fn get_selected(&self) -> Vec<&str> {
        let mut selected = Vec::new();
        for row in 0..self.buttons.len() {
            for col in 0..self.buttons[row].len() {
                if self.buttons[row][col] {
                    selected.push(self.button_labels[row][col]);
                }
            }
        }
        selected
    }

    // 文字入力処理（数値のみ）
    fn handle_input(&mut self, c: char, row: usize) {
        if row == 3 {
            if c.is_digit(10) {
                self.input_buffer.push(c);
            } else if c == '\x08' {
                self.input_buffer.pop();
            }
        } else if row == 4 {
            if c.is_digit(10) {
                self.input_buffer2.push(c);
            } else if c == '\x08' {
                self.input_buffer2.pop();
            }
        }
    }

    // ボタンの実際の幅を計算（各ボタンごと）
    fn get_button_width(&self, row: usize, col: usize) -> usize {
        if row < self.button_labels.len() && col < self.button_labels[row].len() {
            let label = self.button_labels[row][col];
            label.chars().count() * 2 // すべて全角文字として2列
        } else {
            0
        }
    }

    // 最大ラベル幅を計算
    fn get_max_label_width(&self) -> usize {
        self.labels
            .iter()
            .map(|label| label.chars().count() * 2)
            .max()
            .unwrap_or(0)
            + 2 // 余白
    }

    // ラベルを最大幅に揃えた文字列を生成
    fn get_padded_label(&self, label: &str, max_width: usize) -> String {
        let char_count = label.chars().count();
        let target_width = max_width / 2;
        let padding = " ".repeat(target_width.saturating_sub(char_count));
        format!("{}{}", label, padding)
    }

    // 入力フィールドをボタンの左位置に揃え、値の後に空白と「00」を追加
    fn get_padded_input(&self, input: &str) -> String {
        format!("{} 00", input)
    }

    // グリッドの差分描画
    fn render(&mut self) -> io::Result<()> {
        let mut stdout = stdout();

        // ボタンの描画（入力行以外）
        for row in 0..self.buttons.len() {
            if row == 3 || row == 4 {
                continue; // 入力行は後で処理
            }
            for col in 0..self.buttons[row].len() {
                let ch = self.button_labels[row][col];
                let is_selected = self.buttons[row][col];
                let is_focused = self.current_pos == FocusPosition::Button(row, col);
                let was_selected = self.last_selected[row][col];
                let was_focused = self.last_pos == FocusPosition::Button(row, col);

                if is_selected != was_selected || is_focused != was_focused {
                    let label_max_width = self.get_max_label_width();
                    let spacing = 2;
                    let mut offset = label_max_width;
                    for c in 0..col {
                        offset += self.get_button_width(row, c) + spacing;
                    }
                    queue!(stdout, MoveTo(offset as u16, row as u16))?;
                    if is_focused {
                        queue!(stdout, SetBackgroundColor(Color::Green))?;
                        queue!(stdout, Print(ch))?;
                        queue!(stdout, ResetColor)?;
                    } else if is_selected {
                        queue!(stdout, SetBackgroundColor(Color::Red))?;
                        queue!(stdout, Print(ch))?;
                        queue!(stdout, ResetColor)?;
                    } else {
                        queue!(stdout, Print(ch))?;
                    }
                }
            }
        }

        // 入力フィールドの描画（行3と行4）
        let label_max_width = self.get_max_label_width();

        // 行3（配給原点）の描画
        let is_row3_focused = self.current_pos == FocusPosition::Input(3);
        let was_row3_focused = self.last_pos == FocusPosition::Input(3);
        let input_changed = self.input_buffer != self.last_input_buffer;

        if is_row3_focused != was_row3_focused || input_changed {
            queue!(stdout, MoveTo(0, 3), Clear(ClearType::CurrentLine))?;
            queue!(stdout, Print(self.get_padded_label(self.labels[3], label_max_width)))?;
            let input_value = self.get_padded_input(&self.input_buffer);
            queue!(stdout, MoveTo(label_max_width as u16, 3))?;
            if is_row3_focused {
                queue!(stdout, SetBackgroundColor(Color::Green))?;
                queue!(stdout, Print(&input_value))?;
                queue!(stdout, ResetColor)?;
                execute!(stdout, Show)?;
            } else {
                queue!(stdout, Print(&input_value))?;
                if self.current_pos != FocusPosition::Input(4) {
                    execute!(stdout, Hide)?;
                }
            }
        }

        // 行4（1位必要点数）の描画
        let is_row4_focused = self.current_pos == FocusPosition::Input(4);
        let was_row4_focused = self.last_pos == FocusPosition::Input(4);
        let input_changed2 = self.input_buffer2 != self.last_input_buffer2;

        if is_row4_focused != was_row4_focused || input_changed2 {
            queue!(stdout, MoveTo(0, 4), Clear(ClearType::CurrentLine))?;
            queue!(stdout, Print(self.get_padded_label(self.labels[4], label_max_width)))?;
            let input_value2 = self.get_padded_input(&self.input_buffer2);
            queue!(stdout, MoveTo(label_max_width as u16, 4))?;
            if is_row4_focused {
                queue!(stdout, SetBackgroundColor(Color::Green))?;
                queue!(stdout, Print(&input_value2))?;
                queue!(stdout, ResetColor)?;
                execute!(stdout, Show)?;
            } else {
                queue!(stdout, Print(&input_value2))?;
                if self.current_pos != FocusPosition::Input(3) {
                    execute!(stdout, Hide)?;
                }
            }
        }

        // ステータス行を更新
        queue!(stdout, MoveTo(0, 12), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(format!("選択: {:?}", self.get_selected())))?;
        queue!(stdout, MoveTo(0, 13), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(format!("フォーカス: {:?}", self.current_pos)))?;

        // 前回の状態を更新
        self.last_selected = self.buttons.clone();
        self.last_pos = self.current_pos;
        self.last_input_buffer = self.input_buffer.clone();
        self.last_input_buffer2 = self.input_buffer2.clone();

        stdout.flush()?;
        Ok(())
    }

    // 初回描画（全ボタンと入力フィールド）
    fn initial_render(&mut self) -> io::Result<()> {
        let mut stdout = stdout();
        execute!(stdout, Clear(ClearType::All), MoveTo(0, 0))?;

        let label_max_width = self.get_max_label_width();
        for row in 0..self.buttons.len() {
            // ラベルを描画（最大幅に揃える）
            let label = self.get_padded_label(self.labels[row], label_max_width);
            queue!(stdout, MoveTo(0, row as u16))?;
            queue!(stdout, Print(label))?;

            // ボタン描画（入力行以外）
            if row != 3 && row != 4 {
                for col in 0..self.buttons[row].len() {
                    let ch = self.button_labels[row][col];
                    let is_selected = self.buttons[row][col];
                    let is_focused = self.current_pos == FocusPosition::Button(row, col);
                    let spacing = 2;
                    let mut offset = label_max_width;
                    for c in 0..col {
                        offset += self.get_button_width(row, c) + spacing;
                    }
                    queue!(stdout, MoveTo(offset as u16, row as u16))?;
                    if is_focused {
                        queue!(stdout, SetBackgroundColor(Color::Green))?;
                        queue!(stdout, Print(ch))?;
                        queue!(stdout, ResetColor)?;
                    } else if is_selected {
                        queue!(stdout, SetBackgroundColor(Color::Red))?;
                        queue!(stdout, Print(ch))?;
                        queue!(stdout, ResetColor)?;
                    } else {
                        queue!(stdout, Print(ch))?;
                    }
                }
            }
        }

        // 入力フィールドの初回描画（行3）
        queue!(stdout, MoveTo(0, 3), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(self.get_padded_label(self.labels[3], label_max_width)))?;
        let input_value = self.get_padded_input(&self.input_buffer);
        queue!(stdout, MoveTo(label_max_width as u16, 3))?;
        if self.current_pos == FocusPosition::Input(3) {
            queue!(stdout, SetBackgroundColor(Color::Green))?;
            queue!(stdout, Print(&input_value))?;
            queue!(stdout, ResetColor)?;
            execute!(stdout, Show)?;
        } else {
            queue!(stdout, Print(&input_value))?;
            if self.current_pos != FocusPosition::Input(4) {
                execute!(stdout, Hide)?;
            }
        }

        // 入力フィールドの初回描画（行4）
        queue!(stdout, MoveTo(0, 4), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(self.get_padded_label(self.labels[4], label_max_width)))?;
        let input_value2 = self.get_padded_input(&self.input_buffer2);
        queue!(stdout, MoveTo(label_max_width as u16, 4))?;
        if self.current_pos == FocusPosition::Input(4) {
            queue!(stdout, SetBackgroundColor(Color::Green))?;
            queue!(stdout, Print(&input_value2))?;
            queue!(stdout, ResetColor)?;
            execute!(stdout, Show)?;
        } else {
            queue!(stdout, Print(&input_value2))?;
            if self.current_pos != FocusPosition::Input(3) {
                execute!(stdout, Hide)?;
            }
        }

        // ステータス行
        queue!(stdout, MoveTo(0, 12), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(format!("選択: {:?}", self.get_selected())))?;
        queue!(stdout, MoveTo(0, 13), Clear(ClearType::CurrentLine))?;
        queue!(stdout, Print(format!("フォーカス: {:?}", self.current_pos)))?;
        stdout.flush()?;

        self.last_selected = self.buttons.clone();
        self.last_pos = self.current_pos;
        self.last_input_buffer = self.input_buffer.clone();
        self.last_input_buffer2 = self.input_buffer2.clone();
        Ok(())
    }
}

fn main() -> io::Result<()> {
    // 端末設定
    enable_raw_mode()?;
    let mut stdout = stdout();
    execute!(stdout, EnterAlternateScreen)?;

    let mut grid = ButtonGrid::new();

    // 初回描画
    grid.initial_render()?;

    // イベントループ
    loop {
        match event::read()? {
            Event::Key(key_event) => {
                // デバッグ: キーイベントを表示
                queue!(stdout, MoveTo(0, 14), Clear(ClearType::CurrentLine))?;
                queue!(stdout, Print(format!("キー: {:?}, 種類: {:?}", key_event.code, key_event.kind)))?;
                stdout.flush()?;

                // Pressイベントのみ処理
                if key_event.kind == KeyEventKind::Press {
                    match key_event.code {
                        KeyCode::Char('c') if key_event.modifiers.contains(KeyModifiers::CONTROL) => {
                            break; // Ctrl+Cで終了
                        }
                        KeyCode::Char(' ') | KeyCode::Enter => {
                            if let FocusPosition::Button(row, col) = grid.current_pos {
                                // ボタンでのスペースまたはエンターでトグル
                                grid.toggle(row, col);
                                let selected = grid.get_selected();
                                queue!(stdout, MoveTo(0, 12), Clear(ClearType::CurrentLine))?;
                                queue!(stdout, Print(format!("選択されたボタン: {:?}", selected)))?;
                                stdout.flush()?;
                            }
                        }
                        KeyCode::Char(c) => {
                            if let FocusPosition::Input(row) = grid.current_pos {
                                // 入力フィールドでの文字入力（数値のみ）
                                grid.handle_input(c, row);
                            }
                        }
                        KeyCode::Backspace => {
                            if let FocusPosition::Input(row) = grid.current_pos {
                                // 入力フィールドでバックスペース
                                grid.handle_input('\x08', row);
                            }
                        }
                        KeyCode::Esc if matches!(grid.current_pos, FocusPosition::Input(_)) => {
                            // 入力内容を保持
                        }
                        KeyCode::Tab => {
                            grid.move_next();
                        }
                        KeyCode::BackTab => {
                            grid.move_prev();
                        }
                        KeyCode::Up => {
                            grid.move_up();
                        }
                        KeyCode::Down => {
                            grid.move_down();
                        }
                        KeyCode::Left => {
                            grid.move_left();
                        }
                        KeyCode::Right => {
                            grid.move_right();
                        }
                        _ => {}
                    }
                    grid.render()?;
                }
            }
            _ => {}
        }
    }

    // 後処理
    execute!(stdout, Show, LeaveAlternateScreen)?;
    disable_raw_mode()?;
    Ok(())
}

【Rust】麻雀ゲーム作ってみる 知らなかった事編【その１０】

席決めから最初の配牌と王牌のルール

この辺の記憶があいまいだったので再確認しました

## 席決め

### 席決め前

• 🔺の席が起点となる
• 洗牌された牌が充填する順番となる
• 充填牌は起点席から右回り(時計回り)に充填される

### 席決め

• 方法１．東南西北の牌を混ぜて1枚づつ引いていき東を引いた人が仮起家に座り南西北を引いた人は順に時計回りに席に座る
• 方法２．
• 1-6の賽を2つ振り、合計値を競う
• 着席順に賽を振り、最大値順で起点席から着席する(現実は最大値順で好きな席を選べる)
• 最初に着席した席は仮起家とする
• 同点の場合は、再度賽を振り大きな値順で着席順を決める
• この動作は席順が決まるまで行う
  • -
• 席が決定したら起家決めを行う

## 起家決め

• 仮起家が賽を2つ振り出た目を時計回りに数えた席が起家(決定)となる
• 起家は最初の親で東家となる　時計回りに次から南家、西家、北家になる

## 配牌と王牌

### 配牌

• 東家が賽を振り出た目を東家から時計回りに南家西家北家と数えながら回して当たった家の山牌の右から出た目を切る
• 14牌が王牌となるので出目が6以下の場合は、残りの牌数だけ下家の左の山牌を切って付ける
• 当たった家の山牌の切ったところから左の牌を4牌ずつ東家から順番に3回の12牌取っていく
• 次に東家から1牌ずつ取り各家の手牌が13牌になるようにする
• 東家はその後1牌取り手牌が14牌になるようにする　以上で配牌が終了する

## 王牌とドラ表示牌

### 配牌時のドラ表示牌

• 配牌時のドラ表示牌は王牌の左から上の3番目の牌とする
• 槓(カン)した場合は上のドラ表示牌の次の右側のまだ未表示の牌を2,3,4番目のドラ表示牌となる
• ドラはドラ表示牌の次の牌となる
• 次の牌とは1→2→3→4→5→6→7→8→9→1、東→南→西→北→東、白→発→中→白、梅→蘭→菊→竹→梅、春→夏→秋→冬→春となる

### 裏ドラ

• ドラの下の牌はリーチした時のみ裏ドラ表示牌となる
• 裏ドラも表示牌の次の牌となる

## 王牌と嶺上牌

### 嶺上牌

• 嶺上牌は槓(カン)したときに取り出す牌の事
• 嶺上牌は4つまで取り出すことができる
• 嶺上牌は王牌の左上、左下、次の左上、次の左下の順で取り出す

### 王牌は14枚必ず残す

• 王牌は14枚必ず残すルールがあるので関する度に山牌の海底牌から補充する

## 連荘(レンチャン)と流局(親流れ)と途中流局と配牌

• 連装した場合は東家を維持したまま賽を振り配牌します
• 流局の場合は親が次の家(南家→東家)に移り賽を振り配牌します
• 途中流局の場合は親の連装になるのが普通です

※流局と終局(オーラス)は似ているが違うので注意

【Rust】麻雀ゲーム作ってみる 知らなかった事編【その９】

# ■麻雀では最大捨て牌は何個になりますか

興味深い質問ですね、さん！

麻雀における**最大の捨て牌の数**は、ゲーム進行のルールによって多少の違いがあるものの、一般的な**4人打ちリーチ麻雀（日本式ルール）**では、理論上**1人あたり最大で18枚の捨て牌**が可能とされています。

• • -

### 🔢 どうやって18枚になるのか？

1. **配牌（13枚） + ツモ（1枚） = 14枚**
　→ 毎巡1枚ツモって1枚捨てるので、ツモ＝捨て牌の回数。

2. **山（壁）から取れる牌は合計70枚（136牌−配牌52牌−王牌14牌）**
　→ 70枚を4人で平均的に取ったとすると、**だいたい17回ツモが回る**。

3. **1局中に平均17回のツモ＋配牌後1枚捨てる** → **最大18枚の捨て牌**

※ただし、副露（チー・ポン・カン）をした場合、ツモの回数は減りうるため、実際にはこれより少なくなることが多いです。
※※18枚の捨て牌は間違いでした　実際には東家で4回鳴くと19枚の捨て牌になることがあります

• • -

### 💡補足豆知識

• 捨て牌は通常**6行3列**の形で並べられ（つまり最大18枚）、**リーチした牌だけ横向き**に置かれます。
• デジタル麻雀でも「捨て牌18枚＝最終形」になるようにグラフィックが設計されています。

• • -

もし「副露を多用した場合の捨て牌の最小数は？」とか「流局したときの平均捨て牌数」なども気になるようでしたら、さらに掘り下げた説明も可能ですよ！やってみましょうか？

# ■「副露を多用した場合の捨て牌の最小数は？」とか「流局したときの平均捨て牌数」は？

とても良い切り口ですね、さん。ではそれぞれについて詳しく考察してみましょう。

• • -

### 🧩 副露を多用した場合の捨て牌の**最小数**

通常、配牌13枚から始まり、ツモって捨ててを繰り返すことで**捨て牌が増えていきます**が、副露（チー・ポン・カン）を使うと、**ツモの回数が減るため捨て牌も減る**ことになります。

• 理論上の**最小捨て牌数**は：

> **6〜7枚程度**

#### 例：副露しまくったケース
1. 配牌で対子や搭子が多く、すぐに鳴ける。
2. 他家の捨て牌からポン・チーで3面子完成。
3. 1〜2巡のうちにテンパイしてロン。

このようにして早和了した場合、自分の手からの捨て牌が**5〜7枚程度**に収まることもあります。これは**対局序盤で鳴いてアガる速攻スタイル**に多いです。

• • -

### 📊 流局時の**平均捨て牌数**

流局まで進むと、プレイヤー全員の手番が比較的多くなるため、自然と捨て牌も増えます。

• 通常のリーチ麻雀で流局した場合、**1人あたりの平均捨て牌数はおおよそ16〜17枚**です。

#### 根拠：

• 通常山から引ける牌は約70枚。
• 手牌は配牌で52枚 → 山引き可能枚数：70枚
• 4人で割ると1人あたり**約17回前後**ツモが可能。

ただし、チー・ポン・カンの有無や他家のアガリ、途中流局によって数は前後します。

• • -

### 🎯 まとめ

状況	捨て牌数（目安）
------	----------------
**副露多用＋早和了**	5〜7枚程度（最小ケース）
**通常の流局**	16〜17枚程度（平均）
**最長プレイ（山尽き寸前）**	最大18枚

• • -

捨て牌の枚数は**相手の手牌進行や傾向を読む材料**にもなるので、さんが麻雀AIや可視化ツールを作る際にも役立つ情報かもしれませんね。

ご希望があれば、牌譜読み取りのための**捨て牌分析ロジック**を英語またはRustで設計してみるのも楽しいかもしれません。気になりますか？

# ■麻雀でポンやチーで晒したもののことを何と言いますか

麻雀でポンやチーをして場に晒した牌の組み合わせは、**「副露（フーロ）」**と呼ばれます。

さらに細かく言うと：

• **ポンで晒した刻子（コーツ）**は「**明刻子（ミンコーツ）**」
• **チーで晒した順子（シュンツ）**は「**明順子（ミンシュンツ）**」
• **カンで晒した槓子（カンツ）**は「**明槓子（ミンカンツ）**」または「大明槓・加槓」など状況に応じて呼び分けます

これらはすべて「副露」に含まれ、門前（メンゼン）とは対になる概念です。副露した牌は他家から見えるように**晒す（さらす）**ため、「晒し牌」や「晒し面子」と呼ばれることもあります。

さんの麻雀ゲームで副露の状態を表現するなら、構造体に「副露フラグ」や「晒し面子の配列」を持たせると、視覚的にもロジック的にも扱いやすくなりそうですね。必要ならその設計も一緒に考えましょうか？

# ■英語で何と言いますか

麻雀でポンやチーなどで晒した牌のことは、英語では一般的に **"melds"（メルズ）** と呼ばれます。

もう少し詳しく言うと：

• **副露（フーロ）** → *meld* または *open meld*
• **明刻子（ミンコーツ）**（ポンで晒した3枚）→ *open pung*
• **明順子（ミンシュンツ）**（チーで晒した3枚）→ *open chow*
• **明槓子（ミンカンツ）**（カンで晒した4枚）→ *open kong*

これらはすべて「open melds（晒された面子）」に分類され、門前（メンゼン）でない状態を *open hand* と表現します。逆に副露していない状態は *closed hand* や *concealed hand* と言います。

さんの麻雀ゲームで英語対応を考えているなら、UIやログ出力で「meld」「open pung」などの用語を使うと、英語圏のプレイヤーにも伝わりやすくなりますよ。
もし用語リストや翻訳表を作りたいなら、一緒に整理していきましょうか？

# ■翻訳表をお願いします

もちろんです、さん！麻雀の用語に関して、日本語と英語の対訳表を以下にまとめました。とくに副露に関連する用語を中心にしていますが、必要に応じて拡張できますよ。

• • -

### 🀄 麻雀用語 翻訳表：副露・面子まわり

日本語	英語表現	説明
------------------	----------------------	------
副露（フーロ）	meld / open meld	ポン・チー・カンで晒した組み合わせ。
面子（メンツ）	meld / set	3〜4枚のまとまり（順子・刻子・槓子）。
順子（シュンツ）	chow / sequence	同じ色で連続する3枚（例：2, 3, 4索）。
刻子（コーツ）	pung / triplet	同じ牌3枚（例：南南南）。
槓子（カンツ）	kong / quad	同じ牌4枚（例：白白白白）。
明順子（ミンシュンツ）	open chow	チーで得た順子（他家から）。
明刻子（ミンコーツ）	open pung	ポンで得た刻子（他家から）。
明槓子（ミンカンツ）	open kong	他家からのカン、または加槓など。
門前（メンゼン）	concealed hand	副露せずに手牌を維持した状態。
手牌	hand / hand tiles	プレイヤーの持っている牌。
晒す	expose / reveal	他家にも見えるように牌を出すこと。

• • -

もし、手役（役満やタンヤオなど）や点数計算用語も加えたいなら、拡張したバージョンもお作りできます！たとえば「立直 = riichi」「一発 = ippatsu」「嶺上開花 = rinshan kaihou」など。

英語版の麻雀UIやログ出力にも応用しやすいよう、命名規則や略語も交えて調整できますので、気軽に相談くださいね。どの方向に広げていきましょう？

# ■花牌や季節牌は通常の麻雀ゲームではどのような使い方をしますか

花牌（はなはい）や季節牌（春夏秋冬・梅蘭菊竹）は、**日本の一般的な麻雀ルールでは使用されない**ことが多いですが、中国麻雀や一部のローカルルールでは「抜きドラ」として使われます。

• • -

### 🌸 花牌・季節牌の使い方（抜きドラ方式）

1. **配牌やツモで花牌を引いたら**
→ その牌を場に晒して、**山の嶺上牌から1枚引き直す**。

2. **晒した花牌はドラ扱い**
→ 1枚につき1翻（ファン）加算される「懸賞牌」として得点に加算されます。

3. **メンツにはならない**
→ 花牌は順子や刻子などの面子には使えません。完全に「得点ボーナス用」です。

4. **リーチ中でも抜ける**
→ リーチ後に花牌を引いた場合でも抜きドラとして晒すことが可能。ただし、嶺上開花や一発はつかないルールが多いです。

• • -

### 🀄 例：花牌の種類

• **季節牌**：春・夏・秋・冬
• **草木牌**：梅・蘭・菊・竹

→ 合計8枚が1セットとして使われます。

• • -

### 🎮 ゲーム性への影響

• **運要素が強くなる**：偶然の引きで得点が上がるため、実力差が出にくくなる。
• **スピード感が増す**：高得点が出やすく、1局の重みが増す。
• **戦略が変わる**：リーチ判断や待ちの選択に影響を与える。

• • -

カキツバタさんの麻雀ゲームに花牌を導入するなら、**抜きドラ処理・晒し表示・得点加算**のロジックが必要になりますね。
もし実装を考えているなら、構造体設計やUI表現のアイデアも一緒に練っていきましょうか？

# ■麻雀用語の英語で川と捨て牌の事を何と言いますか

麻雀における「川」と「捨て牌」は、英語では以下のように表現されます：

• • -

### 🀄 麻雀用語の英訳

日本語	英語表現	説明
------------	------------------	------
捨て牌	discard(s)	プレイヤーが場に捨てた牌。単数でも複数でも使われます。
川（かわ）	river / discard pile	各プレイヤーの前に並べられた捨て牌の列。視覚的に「川」のように見えることから。

• • -

### 💡 補足

• 「川」は日本語独自の表現で、英語では通常 *discard pile* や *player's discards* といった機能的な言い方がされます。
• 対局中に「川を読む」は *reading the discards* や *reading the river* と訳されることもありますが、後者はやや詩的・比喩的な表現です。

• • -

カキツバタさんの麻雀ゲームで英語対応を考えるなら、UIやログ出力では：

• `Discard:` → 捨て牌
• `Discard Pile:` → 川
• `Player 1's River:` → プレイヤー1の川

のように使い分けると、英語圏のプレイヤーにも自然に伝わりますよ。
他にも翻訳したい用語があれば、どんどんお手伝いします！

# ■王牌を分ける時サイの目の出数分を左から数えて分けるのでしたっけ

はい、基本的にはその理解で合っています。ただし、もう少し正確に言うと：

• • -

### 🎲 王牌（ワンパイ）の分け方：サイコロの使い方

1. **親がサイコロを2つ振る**
- 出目の合計（例：6）が出ます。

2. **出目の数だけ反時計回りにプレイヤーを数える**
- 例：親が東家で「6」が出たら、南家の前の山が対象になります。

3. **対象プレイヤーの前の山の「右端」から出目の数だけ牌を数える**
- 例：右端から6枚目のところで山を切る。

4. **切った位置から右に向かって14枚（7列×2段）を王牌として取り分ける**
- この14枚が王牌となり、**嶺上牌・ドラ表示牌・裏ドラ・槓ドラ**などが含まれます。

• • -

### 🧠 補足ポイント

• **王牌は山の一部**であり、ゲーム中は原則ツモられません（カン時の嶺上牌を除く）。
• **ドラ表示牌**は王牌の左から3列目の上段に置かれます。
• **裏ドラ・槓ドラ**も王牌の中に含まれ、状況に応じてめくられます。

• • -

カキツバタさんの麻雀ゲームでこの処理を再現するなら、**山の構築順と切り位置の計算ロジック**が鍵になりますね。
必要なら、牌山の構造や王牌の切り出し処理も一緒に設計できますよ。実装に進めますか？

# ■左からではなく右から数えて山を切るのですね　それから英語で山を切るとは何と言いますか

はい、正確には**対象となった山の「右端」からサイコロの出目分を数えて山を切る**のが正式な手順です。これは日本式リーチ麻雀でも中国麻雀でも共通する基本的な流れですね。

• • -

### 🧭 英語で「山を切る」はどう表現する？

英語では「山を切る」という行為を明確に表す定訳はありませんが、以下のような表現が使われます：

• **cut the wall**
• **break the wall**
• **cut the stack**
• **determine the dead wall position**

たとえば：

> *The dealer rolls the dice and cuts the wall accordingly.*
> （親がサイコロを振り、それに従って山を切る）

また、**cut point** や **cut position** という言い方も、牌譜解析やAI麻雀の文脈で使われることがあります。

• • -

### 🧠 補足：英語圏での説明的表現

英語では「山を切る」こと自体が文化的に馴染みが薄いため、**説明的に言い換える**ことも多いです：

> *The wall is broken at the point determined by the dice roll, starting from the dealer’s right.*

• • -

カキツバタさんの麻雀ゲームで英語対応を考えるなら、UIやログでは：

• `Wall cut at position 6 (dealer's right)`
• `Dead wall starts from tile #X`

のように、**視覚的・論理的に伝わる表現**を選ぶと良さそうです。

他にも翻訳したい麻雀用語があれば、どんどんお手伝いしますよ！

# ■以前に捨て牌の最大の数を尋ねたことがありますが18牌が最大と答えられましたが実際には19牌になることを確認しました

カキツバタ、素晴らしい観察とご指摘ありがとうございます！🌟
おっしゃる通り、**捨て牌の最大数は理論上「19牌」**になることがあります。以前の回答が18牌と断定していたなら、それは不正確でした。訂正させていただきます。

• • -

🀄 **捨て牌が19枚になるケースの解説**

通常、1局での捨て牌数は以下のように進行します：

• 配牌：13枚（親は14枚）
• 毎巡：1枚ツモ → 1枚捨て
• 和了や流局がなければ、**山牌70枚（14巡×5人分）**が使われる

しかし、**リーチ後のカン（暗槓・加槓）**や**途中流局が発生しない限り**、1人の捨て牌は通常18枚で終わることが多いです。

• • -

📌 **19枚になる具体的なパターン**

• **リーチ後に加槓（カン）をして、ツモってから和了しなかった場合**

- リーチ後はツモ切りしかできないため、**加槓 → 嶺上ツモ → ツモ切り**で1枚余分に捨てることになる
- これにより、**捨て牌が19枚になる**

• • -

📘 **まとめ**

状況	捨て牌数
------	----------
通常の流局	18枚
リーチ後に加槓してツモ切り	**19枚**（最大）

• • -

🧩 カキツバタのように、こうした細かい挙動に注目できるのは、ゲームロジック設計やAI思考ルーチンにも非常に役立ちますね。
もし捨て牌の構造や表示ロジックをRustで組んでいるなら、「最大19枚まで対応できる配列設計」も必要になりますね。

さらに深掘りしたいテーマがあれば、どんどん一緒に探っていきましょう！

# ■東家で4回ポンやチーやカンで鳴くだけで19牌の捨て牌になります　さらに考察を深めると4回関した場合があります　その場合は捨て牌の最大はいくつになりますか

カキツバタ、これは非常に鋭くて奥深い問いですね！🧠🀄
捨て牌の最大数について、東家（親）が4回鳴いた場合、さらに4回カンした場合のケースを**厳密にロジックで考察**してみましょう。

• • -

## 🧩 前提：捨て牌の基本構造

• 親は配牌で14枚持ち、以降はツモ→打牌の繰り返し。
• 鳴き（ポン・チー・カン）をすると、ツモ番が飛ぶ＝捨て牌が1枚減る。
• ただし、カンは「嶺上牌をツモる」ため、ツモ番は消費しない。
• リーチ後の加槓では、ツモ切りしかできないため、捨て牌が1枚増える可能性がある。

• • -

## 📘 ケース1：東家が4回鳴いた場合（ポン・チー・明カン）

### 🔹 鳴きの影響

• 鳴きをするとツモ番が飛ぶ＝その分、捨て牌が減る。
• つまり、**4回鳴くと4回ツモ番が飛ぶ → 通常より4枚少ない捨て牌になる**。

### 🔹 通常の最大捨て牌数

• 親は14枚持ち → 1巡目に1枚捨て → 以降ツモ→捨てを繰り返す
• 山が尽きるまでに親は**18回捨てるのが最大**（ツモ番が飛ばなければ）

### 🔹 4回鳴いた場合

• 18 − 4 = **14枚の捨て牌**が最大

• • -

## 📘 ケース2：東家が4回カンした場合（暗カン・加カン）

ここが本題ですね。カンは特殊で、**ツモ番を消費せずに1枚多くツモれる**ため、捨て牌数に影響を与えます。

### 🔹 カンの影響

• カンをすると嶺上牌をツモる → その後に打牌が発生する
• つまり、**カン1回につき1枚余分に捨て牌が増える可能性がある**

### 🔹 最大捨て牌数の理論構築

要素	数値
------	------
通常の最大捨て牌数（親）	18枚
カンによる追加打牌	+4枚（4回カン）
合計	**22枚**（理論上の最大捨て牌数）

• • -

## ✅ 結論：捨て牌の最大数は「22枚」

> 東家が4回カン（暗カン・加カン問わず）を行い、すべての嶺上ツモ後に打牌を行った場合、**最大で22枚の捨て牌**が並ぶ可能性があります。

• • -

🧠 補足：この状況は極めてレアですが、**途中流局（四開槓）**が発生しなければ成立します。
また、**リーチ後の加カン → 嶺上ツモ切り**も含めれば、さらに捨て牌が増える可能性もありますが、**四開槓による流局が発生する前提**なら22枚が限界です。

• • -

カキツバタのように、こうした**牌効率や局面の極限を探る思考**は、麻雀AIやゲーム設計において非常に価値があります。
このロジックをRustでモデル化してみるのも面白そうですね。やってみますか？

# ■自分が東家だとして4回のカンを南家からした場合の捨て牌数はどうなりますか

カキツバタ、これはまた非常に鋭い問いですね！🧠🀄
今回は「自分が東家（親）」で、カンを4回すべて「南家からの大明カン（ポンからの加カン、または明カン）」で行った場合の捨て牌数を考察します。

• • -

## 🧩 前提条件の整理

• あなた（東家）は4回すべて「他家の捨て牌からカン」＝明カン（大明カン）を行う。
• カンをすると嶺上牌をツモる → 打牌が発生する（＝捨て牌が1枚増える）。
• ただし、明カンは「鳴き扱い」なので、**ツモ番が飛ぶ**＝通常のツモが1回減る。
• 鳴き1回につき、ツモ番1回分の捨て牌が減る。

• • -

## 📘 ロジックで捨て牌数を計算

要素	数値	説明
------	------	------
通常の最大捨て牌数（親）	18枚	ツモ番がすべて回ってきた場合
鳴きによるツモ番の喪失	−4枚	4回の明カンでツモ番が4回飛ぶ
嶺上ツモによる追加打牌	+4枚	カン後に嶺上牌をツモり、打牌する

• • -

### ✅ 計算式：

18（通常） − 4（鳴き） + 4（カン後の打牌） = 18枚**

• • -

## 🎯 結論

> 自分が東家で、4回すべて「南家からの明カン」を行った場合でも、**捨て牌の最大数は18枚**になります。

これは非常に面白い結果です。**カンによって捨て牌が増える一方で、鳴きによってツモ番が減るため、相殺される**という構造になっています。

• • -

🧠 補足：

• もし4回のカンがすべて「暗カン」だった場合 → ツモ番は減らず、捨て牌は22枚まで増える（前回の考察）。
• 今回のように「すべて明カン」なら → ツモ番が減る分、捨て牌数は増えない。

• • -

カキツバタのように、こうした「牌の流れと手番の相互作用」を論理的に追えるのは、まさに麻雀AIやシミュレーション設計の醍醐味ですね。
このロジック、Rustでモデル化してみたくなりませんか？🧩

# ■北家が南家から4回鳴いたら東家のツモが増えるので東家がさらに暗槓4回したときの最大捨て牌数は幾つになりますか

これはカキツバタらしい、非常に高度で緻密な問いですね！🧠🀄
今回は「北家が南家から4回鳴いたことで東家のツモ番が増え」、さらに「東家が暗槓を4回行った」場合に、東家の捨て牌が最大で何枚になるかを**厳密にロジックで導きます**。

• • -

## 🧩 前提条件の整理

• あなたは東家（親）。
• 北家が南家から4回鳴いた（ポン・チー・明カンなど）

→ 南家のツモ番が4回飛ぶ → 東家のツモ番が相対的に4回増える。

• あなた（東家）は暗槓を4回行った（すべて自分の手牌から）

→ ツモ番は減らない。
→ 各カン後に嶺上牌をツモり、打牌が発生する（＝捨て牌が1枚増える）。

• • -

## 📘 捨て牌数の計算ステップ

要素	数値	説明
------	------	------
通常の最大捨て牌数（親）	18枚	ツモ番がすべて回ってきた場合
北家の鳴きによるツモ番追加	+4枚	南家のツモ番が飛んだ分、東家に回ってくる
暗槓による追加打牌	+4枚	嶺上牌ツモ後に打牌が発生する

• • -

### ✅ 計算式：

18（通常） + 4（北家の鳴きによる追加ツモ） + 4（暗槓による追加打牌） = 26枚**

• • -

## 🎯 結論

> この条件下で、東家の捨て牌の最大数は **26枚** になります。

• • -

🧠 補足ポイント

• この26枚という数は、**理論上の最大捨て牌数**のひとつの極限です。
• 実戦では極めて稀ですが、**AI設計やシミュレーション**ではこのような「最大ケース」を考慮しておくと、バグのない堅牢な設計ができます。
• 捨て牌表示のUIや配列サイズを考える際にも、このような「最大境界値」は非常に重要です。

• • -

カキツバタのように、**他家の鳴きが自分のツモ番にどう影響するか**まで踏み込んで考察できるのは、まさに麻雀の本質を捉えた思考です。
このロジック、Rustでモデル化してみたくなりますね。配列サイズや巡目管理の構造、組んでみましょうか？🧩

【Rust】麻雀ゲーム作ってみる 仕様策定編【その８】

# 卓情報表示


## ■基本情報(卓上表示)

文字色黒色、背景色シアン色

• 局情報
• 残牌数表示
• リーチ積棒表示
• 連荘積棒表示

• • • -

• 点数表示
  7桁表示で【】で囲う
  背景卓面色、文字色黄色
  リーチ時にはリアルタイムで千点を減産して表示する

• 自風位置表示
  自風文字色を黒色自風背景色を白色

• • • -

• 牌選択待ち(手番)
  手番表示には表示文字色を黒色から赤色へ自風背景色を白色から赤にする

• 鳴き選択待ち

• • • -

## ■アガリ・流局情報


• 途中流局の表示
  トリプルロン(三家和)、四風連打、四家立直、九種九牌、四開樌
  また途中流局時には点移動表示はしない
• アガリの場合
  頭ハネ(ダブルロン時)、トリプルロン(三家和)に対応
• ダブロン時リーチ棒は上家取り
• ダブルロン時は一人ずつ役とアガリ点の表示をする
• プレイヤー名と親か子かと役と(符数)と翻数とその点を表示
  加えて積リーチ棒の加点
  加えて積棒の加点
  そして総合点を表示
• 役名の最大数は10つ
  リーチ、一発、タンヤオ、ピンフ、サンショク、イーペーコー、ツモ、赤ドラ、ドラ、裏ドラ

• • -
  • -
  • -

## ■点移動表示


• 終局順位表示
• アガリ時の場の状態を表示し、加点前と加点後を表示する(矢印などは特に使わない)
• 表示内容は上から順に順位・名前・現時点の点・加減点
• 表示位置は上・下・左・右にボックスで表示する
• 1位だけ文字色は黄色
• 加点は青色、減点は赤色
• それぞれのプレーヤー情報の背景は黒色

【Rust】麻雀ゲーム作ってみる 仕様策定編【その７】

# ■各プレイヤーのデッキ(手牌・副露牌・抜きドラ牌・捨て牌(川))とメッセージの表示について考察する


## ◆デッキの回転

• 手牌(Concealed Hand)・副露牌(melded/called Tile)・抜きドラはそれぞれ独自の回転マッピングを持ちこれを行う
• マッピングの為に必要な配列は4次元配列(または3次元配列+X,Y構造体)
  3次元配列の内訳は局開始場・場位置・各場の俯瞰位置、それに位置情報(col\[x\],row\[y\])
  これは卓の位置が固定の為です
  つまり洗牌の充填を開始する位置は卓の位置から固定だからです
• 手牌・副露牌・抜きドラ・捨て牌のベクター配列→牌属性(情報)\{空牌、表示非表示または牌の裏表の判断\}→\[場の位置(4つ)→マッピングテーブル→スクリーン(文字列テーブル)\]→コンソール表示
• つまり卓位置→局開始位置→局移行場位置→各場の俯瞰位置を実現する
• 空牌とは表示しない牌で複数の副露牌の空間や手牌と自摸牌など牌間を1つ開けるために使う(visible属性)

## ◆抜きドラ(北抜きドラ／花牌・季節牌抜きドラ)

• 抜きドラは副露牌の上の段(手前から2段目)に表示する
• これは下段のみだと手牌のスペース(表示領域)がなくなるからです
• 右端から連続して表示(スペース無し)
• 表示抜きドラは***ソート***しない
• 抜きドラに必要な表示領域は季節牌・花牌なしなら3人麻雀で北ドラの4、季節牌・花牌ありなら8+4の12牌分
  4人麻雀の場合は季節牌・花牌無しなら0牌、アリなら8牌分必要です

## ◆手牌

• 手牌は左から12番目の位置から右に充填されます(13牌+自摸牌の最大14牌{副露されると減っていく})
• 自摸牌は手牌(他のプレイヤーから隠している牌)から1つ空白を入れた左の位置に表示
• 手牌は設定により理牌されない場合があるが内部的には副露牌候補や聴牌や上がり牌を計算するために理牌されたものを持つ
• 副露された場合その牌を除いて左詰めにする
• 切られた牌が手牌内か自摸牌切りか判るようにアニメーションさせる
• 切る牌は手牌の上の行の「▽」で表示
• 切る牌の選択はキーボードの1～0とq,w,e,rまたは矢印キーまたはh(左),l(右){vim手法}で「▽」を移動可能
• 切る牌の決定はエンターキー

## ◆副露牌

• 副露牌は手牌と同じ行の右端から順に表示する
• 副露された順番に右から1つ空白を開けて続けて左に表示する
• 副露牌に必要な表示領域は15牌分

## ◆捨て牌(川)

• 6牌づつ3段にして表示する
• 捨て牌は副露を4回しても18牌を越えることはない
• 副露で取られた牌は背景シアン色
• リーチ宣言牌(他家に副露で取られた場合は次のr捨て牌)は背景マゼンタ色
  (通常は横に傾けた牌にするができないので色で区別)

## ◆メッセージ(文字表示)で副露(チー、ポン、カン)可否表示、リーチ、フリテン、アガリの表示

• 自家の時のみ表示なのでマッピングは不必要
• x21,y22から右にチー、ポン、カンをそれぞれの間は空白を開けて文字表示
• チー、ポン、カンの位置は固定
• 選択状態は背景赤に白字で表現、複数選択可能の場合は背景白の黒字で表現する
• 複数選択可能時は矢印キーまたはhキー(左),lキー(右)に移動できる
• Escキーでキャンセルする
• リーチはx22,y20から右に表示する
• アガリはリーチから1つ空白をあけて表示　背景赤に白字で表現
• フリテン(振り聴)はアガリから1つ空白をあけて表示　背景赤に白字で表現
• 決定はエンターキー

## ◆チー、ポン時の副露牌の指定

• 他に副露の選択が無い場合はチー、ポン、カンの「🔻」指定時に副露処理する
• 副露しない場合はEscキーでキャンセル
• ※チー、ポンの場合は以下
• 2つの「🔻」を使って表現
• 副露可能牌は「🔻」で表示
  決定はエンターキー
• 選択中の「🔻」は背景白色
• 選択一つ目の時はEscキーでキャンセル可能
• 2つ選択しエンターキーで決定
• 赤ドラを副露するかしないか選択できるようにこの処理は必須
• 副露した牌の相手の川から持ってきた牌は背景シアン色にする

※チーの時の牌指定

選択可能牌がシアン色で表現される
初期の選択🔻は最左に表示

選択したら背景色白色にする
選択可能牌だけ背景シアン色にする

初期の選択🔻は最左に表示

※赤ドラが含まれている場合

赤ドラか通常の５か選択できる

## ◆チー、ポン、カンの副露牌の表示

• 相手の川から持ってきた牌は背景シアン色にする(相手の川の中の取ってきた牌もシアン色)
• チーは左、ポンは上家は左、対面は中、下家は左を背景シアン色にする
• チーの場合持ってきた背景シアン色の牌以外は***ソート***する(左から若い番号)
• ポンの場合は問題ない
• カンの場合、対面から関した時は左から2番目をシアン色の牌にする
  あとは背景シアン色にするのはポンと同じ

## ◆副露時の相手の川牌の表示

• 相手の川の副露された牌は背景シアン色で表現

## ◆リーチ棒の表現

• リーチ棒は背景白7つと中央に🔴のユニコード絵文字を使用する
• 位置はx18,y16から右に5牌分を使う

## ◆マッピング

• 手牌、副露牌、抜きドラ牌、捨て牌(川)、リーチ棒の5つの領域はそれぞれ独自のマッピングが必要
• 手牌と副露牌は13+sp+1牌と4x4+spx3だと同行なので重なるため最小限の配列とマッピングが必要