「Unityでゲーム作る」の記事 - Crieit

【実況ブログ】 Unity でスピードを作ろうぜ（＾～＾）？

2023-01-23T21:44:38+09:00

📅2023-01-23 mon 21:00

「　Unity でスピードのモックアップを作ろうぜ？」

「　お父ん、モックアップしか作らないから　つまんな……」

「　企画書と　設計書のフェーズは　すっ飛ばすんでしょ。
プログラミングしかやらないから」

「　👆 Unity Hub でプロジェクトを作る所から始まるぜ」

「　👆 プロジェクト名は Speed でいいだろ」

「　👆 ファイルが最初から、いくつか　入ってるぜ」

「　👆 Unity Editor が出てくるが、自分が使いやすいように　セットアップしておいたぜ。
ほんとは　ディスプレイいっぱい　でかく広げて作業しているが、
上の画像は　ブログにアップするために　ウィンドウを小さくしているぜ」

「　その　ディスプレイいっぱいに広げたウィンドウの画像も　１回　見せてくれだぜ」

「　👆 こうだぜ」

「　👆 トランプ・ゲーム作るんだから　トランプの画像がいるだろ。
Project ウィンドウの Assets フォルダーの下に Images フォルダーを作って、
右クリックして Show in Explorer をクリックしろだぜ」

「　👆 前に神経衰弱を作った時に描いたものを　フォルダーへぶち込むぜ」

「　👆 Unity Editor からも見えるな」

「　しかし　また　１枚１枚　プレーンを置いて　画像をプレーンにドラッグ＆ドロップ　していくのかだぜ？」

「　👆 それは　きついな……。どないしよ……」

「　前に作った Concentration （コンセントレーション；トランプの神経衰弱ゲーム）を Inport Package （インポート・パッケージ）したらいいんじゃないの？」

「　やってみるか……」

📅2023-01-23 mon 21:44

「　👆　前に Import Package したら中身をぶちまけられたり、ぐちゃぐちゃに壊されたりしたから　嫌なんだが
まだ　プロジェクトを作ったばかりだし　被害もないだろ」

「　👆　開くぜ」

「　👆　コンフリクトは注意してくれるのか」

「　あっ、　カードの ゲーム・オブジェクト が入ってないぜ」

「　Concentration プロジェクトの方でカードのゲーム・オブジェクトをプレファブにして　Assets に入れておけばいいんじゃないの？」

「　👆 Hierarchy ウィンドウにあるだけでは Assets ではないから、 Assets に入れないといけないのか。
下準備が　けっこう居るな。
元のプロジェクトを壊さずに　ゲーム・オブジェクトをプレファブに差し替えられるかな？」

「　👆 Hierarchy ウィンドウから Project ウィンドウへ　ドラッグ＆ドロップで　コピーすることは　でけるみたいだけど」

「　じゃあ　Hierarchy ウィンドウにある方の Hearts 1 フォルダーを消して、
Project ウィンドウにある方の Hearts 1 プレファブを Hierarchy ウィンドウに戻してみろだぜ」

「　👆 何ごともなく　無事　でけたぜ」

「　ふーん　できるんだ」

「　じゃあ　残り５３枚のカードを　プレファブに変換しろだぜ」

「　つら……　ぢごくだ……」

📅2023-01-23 mon 22:11

「　👆　こうやって選択して　一度に持っていけないかな……」

「　👆　おっ、いけたようだぜ」

「　Hierarchy ウィンドウの方の　元のゲーム・オブジェクトも　水色のアイコンに変わってるわよ。
もう　プレファブになってんじゃない？」

「　👆　なんでもいいや…… Export Package しよ」

「　👆　Speed プロジェクトの方で Import Package しよ」

「　👆　プレファブだけ持ってきてもだけで　画像も持ってこないと　リンク切れを起こすか
当たり前と言えば　当たり前だが」

「　👆　画像を持ってきたら　復元した」

「　スクリプトのアタッチが切れているようだぜ？」

「　👆　スクリプトを持ってきたら　復元したぜ」

「　トランプ・カードだけを　インポート・パッケージしやすいような
トランプ・カードだけのプロジェクトを　作っておくべきなんじゃない？」」

「　下ごしらえか。　トランプ・ゲームをよく作るようなら　作っておいた方が良さそうだな」

📅2023-01-23 mon 22:36

「　👆　なんか知らんけど　裏側　剥がれてるから　貼り直しだ　ひ～」

「　検品って　大事ね～」

「　👆　Unity Learn のビギナーコースで学んだところによると、 Prefab を Hierarchy でまた　いじったら、 Inspector ウィンドウの Overrides ドロップダウンリストから
Apply All ボタンを選んで　押せば　プレファブの設定を上書きしてくれるんだったと思う、多分」

「　じゃあ　全部のカードの Apply All ボタンを押すのが終わったら、
Hierarchy ウィンドウのカードを全部消して、
Project ウィンドウにあるカードを Hierarchy ウィンドウへ　ドラッグ＆ドロップしろだぜ」

「　でけた。　今度は　オモテも　ウラも　画像が貼り付いてるぜ」

「　カードができたんだったら、　並べて、
スピードをやってるみたいな　画面を作りなさいよ」

「　画作り（えづくり）か」

「　👆　例えば　赤色のスートのカードだけ　１８０°回転させるとか　Unity Editor を使って操作する。
こういう道具の使い方の基本操作が　すばやいことが　開発屋の　基本のき　だぜ」

「　解説はいいから　早よ　画を作れだぜ」

「　👆　あっ！　カードを裏返そうとしたら　オモテ面と　ウラ面の両方が　ウラの方向いて
ワケが分からなくなった！」

「　やり直せ！」

「　👆　不思議な話だが　プロジェクトにある　カードを全部消して、
エクスポートした自分自身の中身を　再び　自分に入れ直すぜ」

「　👆　オモテ面、ウラ面の２枚で１つのカードを　ひっくり返す　うまい操作が　よく分からん。　疲れた。
今日は　ここまでだぜ」

「　おつ」

📅2023-01-24 tue 00:05 end

📅2023-01-24 tue 20:20 start

「　👆　Speades 3 ゲーム・オブジェクトを選択して Rotation Z を 180 にすれば
オモテ面、ウラ面を１つのまとまりとして　裏返してくれるぜ」

「　１個　１個　ゲーム・オブジェクトを選んで　テキストボックスに 180 を入れていけだぜ」

「　この　カードを１枚ずつ選んで　裏返して　少し持ち上げる　たこ焼き　みたいな作業をやるの
嫌なんだが」

「　もっと　スピーディーにやる方法　あるんじゃないの？」

「　あったとしても　知りようがないぜ。
ここを　プログラミング化できたら　３０分は　縮まる！」

「　👆　反対側にもあって　まだ１５枚もある！」

「　30分　がんばれよ」

「　👆　見た目は　こんなんで　いいかあ」

📅2023-01-24 tue 21:13

「　手札って　最大で　何枚になるの？」

「　パイルを全部　手札に混ぜれば　２０枚だぜ」

「　20枚の手札があるケースも　画作り　してくれだぜ」

「　カードの端を　ちょっと被せつつ並べれば　２０枚は　収まるかな？」

「　WebGL でビルドして　出力結果で　確かめなさいよ」

「　端が切れてるなあ。　カメラの角度が付いてるからかな？」

「　メインカメラの位置を　きっちり　決めてくれだぜ」

「　👆　真上というのも　味気ないんで　ちょっと傾けつつ　整数にまとめたぜ」

「　👆　画作り　は　こんなもんでいいだろ」

「　相手の手札を　前後ひっくり返す意味ってある？」

「　ダイヤの６と、ダイヤの９は　見分けが付かないよな」

「　将棋の駒だって　後手は　ひっくり返ってるだろ　例はある　気にするなだぜ」

📅2023-01-24 tue 22:01

「　ゲーム開始時に　セット　されるプログラムを組みましょうよ」

「　ゲームを作るときは　座標をメモって置くのが　コツだぜ」

「　ｘとｚの正負が逆じゃないか？　カメラが裏向いてんじゃないか？」

「　あれまっ！　ほんとだぜ……」

「　👆　グローバル座標にして　Y軸を回転軸にして　１８０°回転したぜ」

「　👆　座標の目安は　これでいいだろ」

📅2023-01-24 tue 22:28

「　手札は　１枚～２０枚　を　位置調整することになるだろ。
予め　計算式を　まとめてくれだぜ」

「　カード１枚の横幅は　だいたい　１０　のようだぜ。それを元に計算してみるか」

「　👆　横幅が無限にあるのなら、 (カードの枚数 - 1) * -5 の位置から +10 間隔でカードを並べるだけでいいが……」

「　👆　左端が x=-62 、右端が x=62 と決まってて、カードは２０枚あるのだった」

「　62 - (-62) = 124 なので、
横幅 124 の中に 20 枚のカードがあるので、
言い換えると
横幅 124 の中に 19 箇所のカードの隙間があるので、
１つの間隔は 124 / 19 = 6.526... んー　すっきりしないなあ」

「　123.5 なら 19 で割り切れたのにね」

「　割り切ろうとするなだぜ」

左端のカードの位置 + (左から何枚目 - 1) * ((右端のカードの位置 - 左端のカードの位置) / (カードの枚数 - 1))

Example:
    -62 + (左から何枚目 - 1) * (124/19)

「　👆　上式で x 座標はイケるだろう」

「　じゃあ　座標の設計は　終わりだぜ」

📅2023-01-24 tue 23:02

「　カードを配るのって　どうやってプログラミングすんの？」

「　👆　かき集めて　シャッフルして　配るだけだぜ」

📅2023-01-24 tue 23:25

「　ちょっと　やってみてくれだぜ」

「　👆　ゲーム・マネージャーを作る手順は　前にやったから　途中は省略するぜ」

GameManager.cs:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class GameManager : MonoBehaviour
{
    /// 
    /// トランプ・カード
    /// 
    List goPlayingCards = new();

    // Start is called before the first frame update
    void Start()
    {
        for (int i = 1; i < 14; i++)
        {
            goPlayingCards.Add(GameObject.Find($"Clubs {i}"));
            goPlayingCards.Add(GameObject.Find($"Diamonds {i}"));
            goPlayingCards.Add(GameObject.Find($"Hearts {i}"));
            goPlayingCards.Add(GameObject.Find($"Spades {i}"));
        }

        float posY = 0.0f;
        float posYStep = -0.2f;
        float posZ = 42.0f;
        float posZStep = -((42.0f - (-28)) / goPlayingCards.Count);
        for (int i = 0; i < goPlayingCards.Count; i++)
        {
            var card = goPlayingCards[i];
            float x = -62.0f + i * (124 / (goPlayingCards.Count - 1));
            card.transform.position = new Vector3(x, posY, posZ);
            card.transform.rotation = Quaternion.Euler(0, 180, 0);
            posY += posYStep;
            posZ += posZStep;
        }
    }

    // Update is called once per frame
    void Update()
    {

    }
}

「　👆　まず、カードをかき集めて　ざらっと　机に並べるコードを書いてみよう」

「　👆　カードが被ってしまって　数字が　なんにも見えないが、
まあ、かき集めるのは　でけたな」

「　続きはまた今度だぜ」

「　おつ」

📅2023-01-24 tue 23:47

📅2023-01-25 mon 19:05

「　数字が見えるようにしなさいよ」

「　用事のため　あとで」

📅2023-01-25 mon 19:14

📅2023-01-27 fri 20:00

「　Excel でチューリング・マシン作ってたら時間が飛んだぜ。
戻ってきたぜ」

「　数字が見えるようにしなさいよ」

「　👆　画面の座標は　こんな感じか」

「　あっ、しまった！」

「　うっかり　ゲームの配置にしてしまった！」

「　カードのテクスチャーや枚数を検品しないと　不良品が混じってるかもしれないのに……」

「　じゃあ　先に進みましょう。
積みあがってる手札を　裏返しなさいよ」

📅2023-01-27 fri 21:31

「　あれっ！　まだ　時計回りに１８０°回転してないのに　ひっくり返ってるぜ！」

「　じゃあ　１８０°回転して　戻せだぜ」

「　👆　なんか積んでる手札の底が１枚ずれてるな。
まあいいや　進んでる間に　原因が見つかるだろ」

「　じゃあ　先に進みましょう。
場にオープンしているカードを１枚選んで　ルールを気にせず　中央の台札に　積みましょう！」

📅2023-01-27 fri 21:53

「　👆　その前に　カードが　空飛んでるのが気になるぜ　地面を置こう」

「　👆　位置は　こんなもんでいいだろ」

「　UI はどうすんだぜ？　どのカードを選んでるとか」

「　👆　カードを持ち上げてみると……、
カメラアングルと　光源の関係なのか　手前と奥のプレイヤーで　持ち上げた高さが違って見えるぜ」

「　カメラの位置を調整したらどうだぜ？」

「　👆　こつこつ　画作り……」

「　👆　回転も付けた方が　カードゲームっぽいかな？」

    /// 
    /// カードを持ち上げる
    /// 
    /// 
    private void SetFocus(GameObject card)
    {
        var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
        var rotateY = -5; // -5°傾ける
        var rotateZ = -5; // -5°傾ける

        card.transform.position = new Vector3(card.transform.position.x, card.transform.position.y + liftY, card.transform.position.z);
        card.transform.rotation = Quaternion.Euler(card.transform.rotation.eulerAngles.x, card.transform.rotation.eulerAngles.y + rotateY, card.transform.eulerAngles.z + rotateZ);
    }

「　👆　付けた変化を　関数にしておくぜ」

「　行列にした方がよくないかだぜ？　逆関数　作るの　めんどくさいだろ？」

「　そういう最適化は　問題点が出尽くして　完成したあとに　やりたかったら　やればいいんで」

    /// 
    /// 持ち上げたカードを場に戻す
    /// 
    /// 
    private void ResetFocus(GameObject card)
    {
        var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
        var rotateY = -5; // -5°傾ける
        var rotateZ = -5; // -5°傾ける

        // 逆をする
        liftY = -liftY;
        rotateY = -rotateY;
        rotateZ = -rotateZ;

        card.transform.position = new Vector3(card.transform.position.x, card.transform.position.y + liftY, card.transform.position.z);
        card.transform.rotation = Quaternion.Euler(card.transform.rotation.eulerAngles.x, card.transform.rotation.eulerAngles.y + rotateY, card.transform.eulerAngles.z + rotateZ);
    }

「　👆　逆関数をあてれば　持ち上げたカードは場に戻り、
また別のカードを持ち上げれば　カードを選んでいる雰囲気が出るな」

📅2023-01-27 fri 22:40

        // １プレイヤーの１枚目のカードにフォーカスを当てる
        {
            if (0 < goPlayersHandCards[0].Count)
            {
                var goCard = goPlayersHandCards[0][0];
                SetFocus(goCard);
            }
        }
        // １プレイヤーの１枚目のカードのフォーカスを外す
        {
            if (0 < goPlayersHandCards[0].Count)
            {
                var goCard = goPlayersHandCards[0][0];
                ResetFocus(goCard);
            }
        }
        // １プレイヤーの１枚目のカードにフォーカスを当てる
        {
            if (1 < goPlayersHandCards[0].Count)
            {
                var goCard = goPlayersHandCards[0][1];
                SetFocus(goCard);
            }
        }
        // ２プレイヤーの１枚目のカードにフォーカスを当てる
        {
            if (0 < goPlayersHandCards[1].Count)
            {
                var goCard = goPlayersHandCards[1][0];
                SetFocus(goCard);
            }
        }
        // ２プレイヤーの１枚目のカードのフォーカスを外す
        {
            if (0 < goPlayersHandCards[1].Count)
            {
                var goCard = goPlayersHandCards[1][0];
                ResetFocus(goCard);
            }
        }
        // ２プレイヤーの２枚目のカードにフォーカスを当てる
        {
            if (1 < goPlayersHandCards[1].Count)
            {
                var goCard = goPlayersHandCards[1][1];
                SetFocus(goCard);
            }
        }

「　👆　画作り　をしている間は　ベタ書きするぜ」

「　ただ、コードが長くなって　読みにくいよな」

Assets.Scripts.LazyArgs.cs:

namespace Assets.Scripts
{
    /// 
    /// コーディングのテクニックのための仕込み
    /// 
    internal class LazyArgs
    {
        public delegate void SetValue(T value);
    }
}

「　👆　そこで　コードを短く書けるための　仕込み　をするぜ」

Assets.Scripts.GameManager.cs:

    /// 
    /// カードを取得
    /// 
    /// 何番目のプレイヤー
    /// 何枚目のカード
    /// カードをセットする関数
    private void GetCard(int player, int cardIndex, LazyArgs.SetValue setCard)
    {
        if (cardIndex < goPlayersHandCards[player].Count)
        {
            var goCard = goPlayersHandCards[player][cardIndex];
            setCard(goCard);
        }
    }

「　👆　カードを取得するという　ありきたりな関数を書き」

        // １プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(0, 0, (goCard) => SetFocus(goCard));

        // １プレイヤーの１枚目のカードのフォーカスを外す
        GetCard(0, 0, (goCard) => ResetFocus(goCard));

        // １プレイヤーの２枚目のカードにフォーカスを当てる
        GetCard(0, 1, (goCard) => SetFocus(goCard));

        // ２プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(1, 0, (goCard) => SetFocus(goCard));

        // ２プレイヤーの１枚目のカードのフォーカスを外す
        GetCard(1, 0, (goCard) => ResetFocus(goCard));

        // ２プレイヤーの２枚目のカードにフォーカスを当てる
        GetCard(1, 1, (goCard) => SetFocus(goCard));

「　👆　長ったらしかったコードを　ワンライナー（１行）で書けるようにしたぜ」

「　１プレイヤーが 0 で、１枚目が 0 って分かりづらくない？」

「　序数と基数の違いだぜ　別のものなのだから仕方ない　慣れろだぜ」

📅2023-01-27 fri 23:09

「　台札に１枚乗せなさいよ」

        // 右の台札を積み上げる
        {
            float x = rightCenterStackX;
            float y = minY;
            float z = rightCenterStackZ;
            foreach (var goCard in goCenterStacksCards[0])
            {
                SetPosRot(goCard, x, y, z);
                y += 0.2f;
            }
        }

「　👆　このコードだと　使い回しづらいので、使い回しやすい形にするかだぜ」

        // 右の台札を積み上げる
        {
            float x = rightCenterStackX;
            this.rightCenterStacksY = minY;
            float z = rightCenterStackZ;

            foreach (var goCard in goCenterStacksCards[0])
            {
                SetPosRot(goCard, x, this.rightCenterStacksY, z);
                this.rightCenterStacksY += 0.2f;
            }
        }

「　👆　Y座標は　記憶することにしよう」

「　👆　『台札は、場札から１枚抜いて置く』という動作に１本化しようぜ」

        // 左の台札が空っぽの状態
        this.leftCenterStackX = -15.0f;
        this.leftCenterStackY = minY;
        this.leftCenterStackZ = 10.0f;

        // 左の台札を積み上げる
        {
            // 場札の好きなところから１枚抜いて、台札を１枚置く
            var player = 1; // ２プレイヤーが
            var handIndex = 0; // 場札の１枚目から
            var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
            goPlayersHandCards[player].RemoveAt(handIndex);
            var leftRight = 0; // 左の
            goCenterStacksCards[leftRight].Add(goCard); // 台札として置く

            // カードの位置と角度をセット
            SetPosRot(goCard, this.leftCenterStackX, this.leftCenterStackY, this.leftCenterStackZ, angleY: 0.0f);

            // 次に台札に積むカードの高さ
            this.leftCenterStackY += 0.2f;
        }

        // 右の台札が空っぽの状態
        this.rightCenterStackX = 15.0f;
        this.rightCenterStackY = minY;
        this.rightCenterStackZ = 0.0f;

        // 右の台札を積み上げる
        {
            var player = 0; // １プレイヤーが
            var handIndex = 0; // 場札の１枚目から
            var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
            goPlayersHandCards[player].RemoveAt(handIndex);
            var leftRight = 1; // 右の
            goCenterStacksCards[leftRight].Add(goCard); // 台札として置く

            // カードの位置と角度をセット
            SetPosRot(goCard, this.rightCenterStackX, this.rightCenterStackY, this.rightCenterStackZ);

            // 次に台札に積むカードの高さ
            this.rightCenterStackY += 0.2f;
        }

「　👆　左の台札と、右の台札を　別にした方がいいな。
カードの移動があったときに、同時に　ポリゴンの位置と角度も設定しよう」

📅2023-01-27 fri 23:50

    /// 
    /// 場札の好きなところから１枚抜いて、台札を１枚置く
    /// 
    /// 何番目のプレイヤー
    /// 何枚目のカード
    /// 左なら1、右なら0
    private void PutCardToCenterStack(int player, int handIndex, int leftRight)
    {
        var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
        goPlayersHandCards[player].RemoveAt(handIndex);
        goCenterStacksCards[leftRight].Add(goCard); // 台札として置く

        // カードの位置をセット
        SetPosRot(goCard, this.centerStacksX[leftRight], this.centerStacksY[leftRight], this.centerStacksZ[leftRight]);

        // 次に台札に積むカードの高さ
        this.centerStacksY[leftRight] += 0.2f;
    }

「　👆　一本化すれば　こんな感じか」

        // 左の台札が空っぽの状態
        this.centerStacksX[1] = -15.0f;
        this.centerStacksY[1] = minY;
        this.centerStacksZ[1] = 10.0f;

        // 右の台札が空っぽの状態
        this.centerStacksX[0] = 15.0f;
        this.centerStacksY[0] = minY;
        this.centerStacksZ[0] = 0.0f;

        // 左の台札を積み上げる
        {
            PutCardToCenterStack(
                player: 1, // ２プレイヤーが
                handIndex: 0, // 場札の１枚目から
                leftRight: 0 // 左の
                );
        }

        // 右の台札を積み上げる
        {
            PutCardToCenterStack(
                player: 0, // １プレイヤーが
                handIndex: 0, // 場札の１枚目から
                leftRight: 1 // 右の
                );
        }

「　👆　ゲーム開始時の台札は　こんな感じに置く」

    IEnumerator DoDemo()
    {
        float seconds = 1.0f;

        yield return new WaitForSeconds(seconds);

        // １プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(0, 0, (goCard) => SetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // １プレイヤーの１枚目のカードのフォーカスを外す
        GetCard(0, 0, (goCard) => ResetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // １プレイヤーの２枚目のカードにフォーカスを当てる
        GetCard(0, 1, (goCard) => SetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // １プレイヤーの２枚目のカードのフォーカスを外す
        GetCard(0, 1, (goCard) => ResetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // 右の台札を積み上げる
        {
            PutCardToCenterStack(
                player: 0, // １プレイヤーが
                handIndex: 1, // 場札の２枚目から
                leftRight: 1 // 右の台札
                );
        }

        yield return new WaitForSeconds(seconds);

        // -

        // ２プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(1, 0, (goCard) => SetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // ２プレイヤーの１枚目のカードのフォーカスを外す
        GetCard(1, 0, (goCard) => ResetFocus(goCard));

        yield return new WaitForSeconds(seconds);

        // ２プレイヤーの２枚目のカードにフォーカスを当てる
        GetCard(1, 1, (goCard) => SetFocus(goCard));

        yield return new WaitForSeconds(seconds);
    }

「　👆　あっ、そうだ　コルーチン使お」

「　👆　台札に置けるぜ」

「　次は、手札から　１枚取ってきて　場札として置く動作を作りなさいよ。
そのとき　場札の位置が　歯抜けだったりするだろうから、位置の再調整がいるかもしれないわね」

「　今日はここまでだぜ」

「　おつ」

📅2023-01-28 fri 00:20 end

📅2023-01-28 sat 17:51

「　👇　場札を並べるコードは　以下のように書いているんだが……」

Assets.Scripts.GameManager.cs :

        // ２プレイヤーの場札を並べる（画面では、左から右へ並べる）
        {
            float x = maxX;
            float y = minY;
            float z = player2HandZ;
            float xStep = (maxX - minX) / (goPlayersHandCards[1].Count - 1);
            foreach (var goCard in goPlayersHandCards[1])
            {
                SetPosRot(goCard, x, y, z, angleY: 0.0f);
                x -= xStep;
            }
        }

        // 中略        

        // １プレイヤーの場札を並べる（画面では、右から左へ並べる）
        {
            float x = minX;
            float y = minY;
            float z = player1HandZ;
            float xStep = (maxX - minX) / (goPlayersHandCards[0].Count - 1);
            foreach (var goCard in goPlayersHandCards[0])
            {
                SetPosRot(goCard, x, y, z);
                x += xStep;
            }
        }

「　👆　１プレイヤーが　右から左へ、　２プレイヤーが　左から右へ、　みたいな　方向がまったく逆のものを
１本化　するのは　ちょっと　すっきりしない方法を使うぜ」

public class GameManager : MonoBehaviour
{
    /// 
    /// 西端
    /// 
    readonly float minX = -62.0f;

    /// 
    /// 東端
    /// 
    readonly float maxX = 62.0f;

    /// 
    /// 底端
    /// 
    /// - `0.0f` は盤
    /// 
    readonly float minY = 0.5f;

    readonly float player2HandZ = 42.0f;
    readonly float player2PileZ = 26.0f;
    readonly float player1PileZ = -12.0f;
    readonly float player1HandZ = -28.0f;

「　👆　その前に　決まりきった座標を　読取専用でメソッドからアクセスできる自由変数にしておこうぜ」

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCardsP2(int player)
    {
        // ２プレイヤーの場札を並べる（画面では、左から右へ並べる）
        float x = maxX;
        float xStep = (maxX - minX) / (goPlayersHandCards[player].Count - 1);
        foreach (var goCard in goPlayersHandCards[player])
        {
            SetPosRot(goCard, x, minY, player2HandZ, angleY: 0.0f);
            x -= xStep;
        }
    }

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCardsP1(int player)
    {
        // １プレイヤーの場札を並べる（画面では、右から左へ並べる）
        float x = minX;
        float xStep = (maxX - minX) / (goPlayersHandCards[player].Count - 1);
        foreach (var goCard in goPlayersHandCards[player])
        {
            SetPosRot(goCard, x, minY, player1HandZ);
            x += xStep;
        }
    }

「　👆　プログラマーのやってることって、違う書き方のコードを１本化することだよな。
この２つを　１本化しようぜ？」

「　👆　プレイヤー１と２で　違う変数を使っているのを止めて、配列かリストにしようぜ？」

    readonly float[] handCardsZ = new[] { -28.0f, 42.0f };
    readonly float[] pileCardsZ = new[] { -12.0f, 26.0f };

「　👆　こう」

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCards(int player)
    {
        float angleY;
        float stepSign;
        float x;

        switch (player)
        {
            case 0:
                // １プレイヤーの場札は、画面では、右から左へ並べる
                angleY = 180.0f;
                stepSign = 1;
                x = minX;
                break;

            case 1:
                // ２プレイヤーの場札は、画面では、左から右へ並べる
                angleY = 0.0f;
                stepSign = -1;
                x = maxX;
                break;

            default:
                throw new Exception();
        }

        float xStep = stepSign * (maxX - minX) / (goPlayersHandCards[player].Count - 1);
        foreach (var goCard in goPlayersHandCards[player])
        {
            SetPosRot(goCard, x, minY, handCardsZ[player], angleY: angleY);
            x += xStep;
        }
    }

「　👆　１本化したら　こうなったぜ」

📅2023-01-28 sat 18:46

「　👆　次は　『手札から１枚抜いて場札に置く』というモーションを１つの関数にしたいぜ」

「　せっかく　ｎ枚　指定できる作りなのに……」

「　じゃあ　ｎ枚　のところも残すか……」

    /// 
    /// 手札からｎ枚抜いて、場札へ移動する
    /// 
    /// - 場札は並び直される
    /// 
    void AddCardsToHandFromPile(int player, int numberOfCards)
    {
        // 手札からｎ枚抜いて、場札へ移動する
        var goCards = goPlayersPileCards[player].GetRange(0, numberOfCards);
        goPlayersPileCards[player].RemoveRange(0, numberOfCards);
        goPlayersHandCards[player].AddRange(goCards);

        // 場札を並べる
        ArrangeHandCards(player);
    }

「　👆　こんな感じで」

📅2023-01-28 sat 19:12

「　手札を先頭から抜いたら、後ろのカードが浮いたままになってしまうわよ？」

「　確かに」

「　先頭から抜くのが　おかしいのでは？　後ろから抜けだぜ」

「　もっともだぜ」

    /// 
    /// 手札の上の方からｎ枚抜いて、場札の後ろへ追加する
    /// 
    /// - 画面上の場札は位置調整される
    /// 
    void AddCardsToHandFromPile(int player, int numberOfCards)
    {
        // 手札の上の方からｎ枚抜いて、場札へ移動する
        var length = goPlayersPileCards[player].Count; // 手札の枚数
        if (numberOfCards <= length)
        {
            var startIndex = length - numberOfCards;
            var goCards = goPlayersPileCards[player].GetRange(startIndex, numberOfCards);
            goPlayersPileCards[player].RemoveRange(startIndex, numberOfCards);
            goPlayersHandCards[player].AddRange(goCards);

            // 場札を並べる
            ArrangeHandCards(player);
        }
    }

「　👆　こうかな」

📅2023-01-28 sat 19:51

「　👆　画作り　を進め中」

「　👆　スピードをやってて、手札を積み上げるのって　全部で　どういうケースがあるの？」

「　初回で　カードを配るときじゃないか？
ゲームが始まったら　手札にカードを積む　という動きは無いだろ」

「　初回は、どこから手札にカードが飛んでくるの？」

「　どこからでもない。
Unity のシーン上に　ゲーム・オブジェクトが適当に散らばっているぜ」

「　関数にしたいのよ。
『どこかに置いてあって、それを手札に積む』という定型パターンに乗せたいから、
どこかに置いてあることにしなさいよ」

「　手札以外には、台札と　場札しかないぜ。
そのどっちかだろ」

「　じゃあ　ゲーム開始時に　散らばっているカードは
台札という扱いにして、ゲーム開始時に　『台札を色分けして、手札に積む』という定型パターンに乗せなさいよ」

    // 台札
    float[] centerStacksX = { 15.0f, -15.0f };

    /// 
    /// 台札のY座標
    /// 
    /// - 右が 0、左が 1
    /// - 0.0f は盤なので、それより上にある
    /// 
    float[] centerStacksY = { 0.5f, 0.5f };
    float[] centerStacksZ = { 0.0f, 10.0f };

「　👆　台札の一番上のカードのY座標を　外側に追いやって……」

    /// 
    /// 台札を、手札へ移動する
    /// 
    /// 右:0, 左:1
    void AddCardsToPileFromCenterStacks(int rightLeft)
    {
        // 台札の一番上（一番後ろ）のカードを１枚抜く
        var numberOfCards = 1;
        var length = goCenterStacksCards[rightLeft].Count; // 手札の枚数
        if (1 <= length)
        {
            var startIndex = length - numberOfCards;
            var goCard = goCenterStacksCards[rightLeft].ElementAt(startIndex);
            goCenterStacksCards[rightLeft].RemoveAt(startIndex);

            // 黒いカードは１プレイヤー、赤いカードは２プレイヤー
            int player;
            float angleY;
            if (goCard.name.StartsWith("Clubs") || goCard.name.StartsWith("Spades"))
            {
                player = 0;
                angleY = 180.0f;
            }
            else if (goCard.name.StartsWith("Diamonds") || goCard.name.StartsWith("Hearts"))
            {
                player = 1;
                angleY = 0.0f;
            }
            else
            {
                throw new Exception();
            }

            // プレイヤーの手札を積み上げる
            goPlayersPileCards[player].Add(goCard);
            SetPosRot(goCard, pileCardsX[player], pileCardsY[player], pileCardsZ[player], angleY: angleY, angleZ: 180.0f);
            pileCardsY[player] += 0.2f;
        }
    }

「　👆　台札を手札へ移動する動きも　１本化するぜ」

    void Start()
    {
        // ゲーム開始時、とりあえず、すべてのカードは、いったん右の台札という扱いにする
        for (int i = 1; i < 14; i++)
        {
            // 右の台札
            goCenterStacksCards[0].Add(GameObject.Find($"Clubs {i}"));
            goCenterStacksCards[0].Add(GameObject.Find($"Diamonds {i}"));
            goCenterStacksCards[0].Add(GameObject.Find($"Hearts {i}"));
            goCenterStacksCards[0].Add(GameObject.Find($"Spades {i}"));
        }

        // 右の台札をシャッフル
        var rightLeft = 0;// 右
        goCenterStacksCards[rightLeft] = goCenterStacksCards[rightLeft].OrderBy(i => Guid.NewGuid()).ToList();

        // 右の台札をすべて、色分けして、黒色なら１プレイヤーの、赤色なら２プレイヤーの、手札に乗せる
        while (0 < goCenterStacksCards[rightLeft].Count)
        {
            AddCardsToPileFromCenterStacks(rightLeft);
        }

「　👆　それに引きずられて、開始時の処理も変えるぜ」

📅2023-01-28 sat 21:17

        // ２プレイヤーが、場札の１枚目を抜いて、左の台札へ積み上げる
        PutCardToCenterStack(
            player: 1, // ２プレイヤーが
            handIndex: 0, // 場札の１枚目から
            rightLeft: 0 // 左の
            );
        // ２プレイヤーの場札の位置調整
        ArrangeHandCards(1);

        // １プレイヤーが、場札の１枚目を抜いて、右の台札へ積み上げる
        PutCardToCenterStack(
            player: 0, // １プレイヤーが
            handIndex: 0, // 場札の１枚目から
            rightLeft: 1 // 右の
            );
        // １プレイヤーの場札の位置調整
        ArrangeHandCards(0);

「　👆　場札の位置調整を　毎回書くのも煩わしいから　関数の中に入れるかだぜ」

    /// 
    /// 場札の好きなところから１枚抜いて、台札を１枚置く
    /// 
    /// 何番目のプレイヤー
    /// 何枚目のカード
    /// 右なら0、左なら1
    private void PutCardToCenterStackFromHand(int player, int handIndex, int rightLeft)
    {
        var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
        goPlayersHandCards[player].RemoveAt(handIndex);
        goCenterStacksCards[rightLeft].Add(goCard); // 台札として置く

        // カードの位置をセット
        SetPosRot(goCard, this.centerStacksX[rightLeft], this.centerStacksY[rightLeft], this.centerStacksZ[rightLeft]);

        // 次に台札に積むカードの高さ
        this.centerStacksY[rightLeft] += 0.2f;

        // 場札の位置調整
        ArrangeHandCards(player);
    }

「　👆　モデルへの編集と、画面への編集は　同じ関数に入れない方がいいんだが、
それは　あとで考えるぜ。
関数名も変更」

    void Start()
    {
        // ゲーム開始時、とりあえず、すべてのカードは、いったん右の台札という扱いにする
        const int right = 0;// 台札の右
        const int left = 1;// 台札の左
        for (int i = 1; i < 14; i++)
        {
            // 右の台札
            goCenterStacksCards[right].Add(GameObject.Find($"Clubs {i}"));
            goCenterStacksCards[right].Add(GameObject.Find($"Diamonds {i}"));
            goCenterStacksCards[right].Add(GameObject.Find($"Hearts {i}"));
            goCenterStacksCards[right].Add(GameObject.Find($"Spades {i}"));
        }

        // 右の台札をシャッフル
        goCenterStacksCards[right] = goCenterStacksCards[right].OrderBy(i => Guid.NewGuid()).ToList();

        // 右の台札をすべて、色分けして、黒色なら１プレイヤーの、赤色なら２プレイヤーの、手札に乗せる
        while (0 < goCenterStacksCards[right].Count)
        {
            AddCardsToPileFromCenterStacks(right);
        }

        // １，２プレイヤーについて、手札から５枚抜いて、場札として置く（画面上の場札の位置は調整される）
        AddCardsToHandFromPile(player: 0, numberOfCards: 5);
        AddCardsToHandFromPile(player: 1, numberOfCards: 5);

        // ２プレイヤーが、場札の１枚目を抜いて、左の台札へ積み上げる
        PutCardToCenterStackFromHand(
            player: 1, // ２プレイヤーが
            handIndex: 0, // 場札の１枚目から
            place: left // 左の
            );

        // １プレイヤーが、場札の１枚目を抜いて、右の台札へ積み上げる
        PutCardToCenterStackFromHand(
            player: 0, // １プレイヤーが
            handIndex: 0, // 場札の１枚目から
            place: right // 右の
            );

        StartCoroutine("DoDemo");
    }

「　👆　開始時のコードが　かなり短くなっただろ」

📅2023-01-28 sat 21:37

「　👆　場札の間隔が空きすぎていて、スピードをしてる感じ、しなくない？」

「　均等割り付け なんだぜ」

「　隙間を詰めてくれだぜ」

「　👆　こういう感じか。　まるで　プロポーショナル・フォント　みたいだな」

「　👆　カードの境界線が見えないから　１枚の長い紙みたいに見えるわよ」

「　世界に　境界線というものは　無いので……」

「　カードを少し傾けたらどうだぜ？」

📅2023-01-28 sat 22:09

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCards(int player)
    {
        int numberOfCards = goPlayersHandCards[player].Count; // カードの枚数
        if (numberOfCards < 1)
        {
            return;
        }

        float cardAngleZ = -5; // カードの少しの傾き
        float cardWidth = 10; // カードの横幅
        float marginRight = -2; // カードは隣のカードと少し重なる
        float wholeWidth = numberOfCards * cardWidth + ((numberOfCards - 1) * marginRight); // 場札全体の横幅
        float centerOfLeftestCard = -(wholeWidth / 2 - (cardWidth / 2)); // １プレイヤーから見て一番左のカードの中心座標

        float angleY;
        float stepSign;
        float x;

        switch (player)
        {
            case 0:
                // １プレイヤーの場札は、画面では、右から左へ並べる
                angleY = 180.0f;
                stepSign = 1;
                x = centerOfLeftestCard;
                break;

            case 1:
                // ２プレイヤーの場札は、画面では、左から右へ並べる
                angleY = 0.0f;
                stepSign = -1;
                x = -centerOfLeftestCard;
                break;

            default:
                throw new Exception();
        }

        float xStep = stepSign * (cardWidth + marginRight);
        foreach (var goCard in goPlayersHandCards[player])
        {
            SetPosRot(goCard, x, minY, handCardsZ[player], angleY: angleY, angleZ: cardAngleZ);
            x += xStep;
        }
    }

「　👆　２プレイヤー側は　いい感じに影が付いたが、１プレイヤー側は　光の当たり方のせいで　思ったようにはなってないぜ」

「　扇状に並べたら　いい感じになるんじゃない？」

📅2023-01-28 sat 22:17

「　👆　頭の運動不足の頭では　ｎ枚のとき角度は何ｍがいいのか　ぱっと出てこないが　まあ　手調整してみるか」

「　👆　こんな式だったかな？」

「　Y は空を指してるから、テーブルの奥は Z ね」

📅2023-01-28 sat 22:58

「　👆　うーん、　どうすればいいのか。ちょっと　考えようか」

「　👆　これで行ってみるかだぜ」

「　👆　わたしは恥ずかしい。一発で決めれない」

「　何発で決まったとか　ユーザーには分かんないから　目視確認と　手調整を繰り返せばいいのよ」

「　半径が 100、スタートの角度が 110°、間隔の角度は -4°　でこれだから、
もっと半径を大きくして　カーブを緩くするか」

「　👆　半径が 200、スタートの角度が 112°、間隔の角度は -1.83°、円の中心のz位置を +10」

「　うまく画面に収めたが、ゲーム中にこんなケースは出てこないのでは？」

「　盤の周りが　スカスカに空いてる分には　ユーザーも困らないでしょう」

「　👆　2P側も　どう見えるか確認だぜ」

「　台札は　カードが積み重なっていくはずだから、　画面の下側に　気持ち　ずらした方がよくない？」

📅2023-01-28 sat 22:58

「　👆　几帳面に真上に積むから　２Pのカードと被って見えることは無さそうだぜ」

「　几帳面に積まれるのも　スピードな感じは　しないわねえ」

「　👆　ランダムにずれを入れると　どこに行くか　わからんけど」

「　もっと　上下の空いてる方向に　伸びなさいよ」

「　👆　こうかだぜ？」

「　スピードな感じは　しないわねえ」

「　台札の所定の位置から離れていくのが　おかしいのと、
カードが几帳面に　正方形の角度が　ぶれてないのが　おかしいんだぜ」

「　なるほど」

「　👆　こうかだぜ？」

「　少しは　揃えて置こうと　してほしいわねえ」

「　１プレイヤー、２プレイヤーが　右利きか、左利きかでも　変わってくるんじゃないかだぜ？」

「　そんなん　設定するのも　嬉しさがあるのか分からないので　右利き　ということにしとこうぜ？」

「　👆　少しは揃えてみたのと、１プレイヤーと　２プレイヤーで　大きく捻る回転方向を　ずらしたぜ」

「　良くは　なってきたわね」

    /// 
    /// ぴったり積むと不自然だから、X と Z を少しずらすための仕組み
    /// 
    /// - １プレイヤー、２プレイヤーのどちらも右利きと仮定
    /// 
    /// 
    /// 
    (float, float, float) MakeShakeForCenterStack(int player)
    {
        // １プレイヤーから見て。左上にずれていくだろう
        var left = -1.5f;
        var right = 0.5f;
        var bottom = -0.5f;
        var top = 1.5f;
        var angleY = UnityEngine.Random.Range(-10, 40); // 反時計回りに大きく捻りそう

        switch (player)
        {
            case 0:
                return (UnityEngine.Random.Range(left, right), UnityEngine.Random.Range(bottom, top), angleY);

            case 1:
                return (UnityEngine.Random.Range(-right, -left), UnityEngine.Random.Range(-top, -bottom), angleY);

            default:
                throw new Exception();
        }
    }

📅2023-01-29 sat 00:42

「　👆　カードのセンタリングが　まだ作ってないので　作るぜ」

「　👆　なんか　手札が　めっちゃ遠くに見えるな」

「　そりゃ、２５枚の場札に合わせた位置だしな」

ソースコード:

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCards(int player)
    {
        // 25枚の場札が並べるように調整してある

        int numberOfCards = goPlayersHandCards[player].Count; // カードの枚数
        if (numberOfCards < 1)
        {
            return;
        }

        float cardAngleZ = -5; // カードの少しの傾き

        int range = 200; // 半径。大きな円にするので、中心を遠くに離したい
        int offsetCircleCenterZ; // 中心位置の調整

        float angleY;
        float playerTheta;
        // float leftestAngle = 112.0f;
        float angleStep = -1.83f;
        float startTheta = (numberOfCards * Mathf.Abs(angleStep) / 2 - Mathf.Abs(angleStep) / 2 + 90.0f) * Mathf.Deg2Rad;
        float thetaStep = angleStep * Mathf.Deg2Rad; ; // 時計回り

        float ox = 0.0f;
        float oz = handCardsZ[player];


        switch (player)
        {
            case 0:
                // １プレイヤー
                angleY = 180.0f;
                playerTheta = 0;
                offsetCircleCenterZ = -190;
                break;

            case 1:
                // ２プレイヤー
                angleY = 0.0f;
                playerTheta = 180 * Mathf.Deg2Rad;
                offsetCircleCenterZ = 188;  // カメラのパースペクティブが付いているから、目視で調整
                break;

            default:
                throw new Exception();
        }

        float theta = startTheta;
        foreach (var goCard in goPlayersHandCards[player])
        {
            float x = range * Mathf.Cos(theta + playerTheta) + ox;
            float z = range * Mathf.Sin(theta + playerTheta) + oz + offsetCircleCenterZ;

            SetPosRot(goCard, x, minY, z, angleY: angleY, angleZ: cardAngleZ);
            theta += thetaStep;
        }
    }

「　👆　このコードは　まあ　こんなもんだろ」

「　👆　目視確認と　感覚で　調整」

「　画作り　は、こんなもんでいいでしょ」

📅2023-01-29 sat 01:04

「　次は　入力　を作っていきましょう」

「　カーソル・キーの　左、右で　ピックアップしている場札を　隣の札に変えるようにしましょう」

「　すると、今どの場札に　フォーカスが当たっているかを　変数として持ちたいよな」

「　でも　今日はここまでだぜ」

「　おつ」

📅2023-01-29 sat 01:23

📅2023-01-29 sat 15:05

「　入力を受け取る部分を　まず書くか」

Assets.Scripts.GameManager.cs :

    void Update()
    {
        // １プレイヤー
        if (Input.GetKey(KeyCode.UpArrow))
        {
            // TODO 選択中の場札を１枚抜いて、左の台札に置く
        }
        else if (Input.GetKey(KeyCode.DownArrow))
        {
            // TODO 選択中の場札を１枚抜いて、右の台札に置く
        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            // TODO 左隣の場札を選択する
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            // TODO 右隣の場札を選択する
        }

        // ２プレイヤー
        if (Input.GetKey(KeyCode.W))
        {
            // TODO （１プレイヤー視点で言うと）選択中の場札を１枚抜いて、右の台札に置く
        }
        else if (Input.GetKey(KeyCode.S))
        {
            // TODO （１プレイヤー視点で言うと）選択中の場札を１枚抜いて、左の台札に置く
        }
        else if (Input.GetKeyDown(KeyCode.A))
        {
            // TODO （１プレイヤー視点で言うと）右隣の場札を選択する
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            // TODO （１プレイヤー視点で言うと）右隣の場札を選択する
        }
    }

「　👆　スピードの操作って　他にある？」

「　だいたい　こんなもんでしょう。
あとで　気づいたら　そのとき　追加しましょう」

📅2023-01-29 sat 15:24

Assets.Scripts.GameManager.cs :

    /// 
    /// プレイヤーが選択しているカードは、先頭から何枚目
    /// 
    int[] playsersFocusedCardIndex ={ 0, 0 };

「　👆　何枚目のカードを選択しているか、覚えさせることにするぜ」

    /// 
    /// 左（前側）のカードをフォーカスします
    /// 
    /// 
    void MoveFocusToLeftCard(int player)
    {
        var previous = playsersFocusedCardIndex[player];
        var current = previous - 1;

        if (current < 1)
        {
            return;
        }

        // 前にフォーカスしていたカードを、盤に下ろす
        var goPreviousCard = goPlayersHandCards[player][previous];
        ResetFocusHand(goPreviousCard);

        // 今回フォーカスするカードを持ち上げる
        var goCurrentCard = goPlayersHandCards[player][current];
        SetFocusHand(goCurrentCard);
    }

    /// 
    /// 右（後ろ側）のカードをフォーカスします
    /// 
    /// 
    void MoveFocusToRightCard(int player)
    {
        var previous = playsersFocusedCardIndex[player];
        var current = previous + 1;

        if (goPlayersHandCards[player].Count <= current)
        {
            return;
        }

        // 前にフォーカスしていたカードを、盤に下ろす
        var goPreviousCard = goPlayersHandCards[player][previous];
        ResetFocusHand(goPreviousCard);

        // 今回フォーカスするカードを持ち上げる
        var goCurrentCard = goPlayersHandCards[player][current];
        SetFocusHand(goCurrentCard);
    }

「　👆　こうかなあ？」

📅2023-01-29 sat 15:42

「　１本化しろだぜ」

    /// 
    /// 隣のカードへフォーカスを移します
    /// 
    /// 
    /// 後ろ:0, 前:1
    void MoveFocusToNextCard(int player, int direction)
    {
        int previous;
        int current;

        switch (direction)
        {
            case 0:
                previous = playsersFocusedCardIndex[player];
                current = previous + 1;

                if (goPlayersHandCards[player].Count <= current)
                {
                    return;
                }
                break;

            case 1:
                previous = playsersFocusedCardIndex[player];
                current = previous - 1;

                if (current < 0)
                {
                    return;
                }
                break;

            default:
                throw new Exception();
        }

        // 前にフォーカスしていたカードを、盤に下ろす
        var goPreviousCard = goPlayersHandCards[player][previous];
        ResetFocusHand(goPreviousCard);

        // 今回フォーカスするカードを持ち上げる
        var goCurrentCard = goPlayersHandCards[player][current];
        SetFocusHand(goCurrentCard);

        // 更新
        playsersFocusedCardIndex[player] = current;
    }

「　👆　こうかなあ？」

📅2023-01-29 sat 15:45

古いコード:

        // １プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(0, 0, (goCard) => SetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

        // １プレイヤーの１枚目のカードのフォーカスを外す
        GetCard(0, 0, (goCard) => ResetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

        // １プレイヤーの２枚目のカードにフォーカスを当てる
        GetCard(0, 1, (goCard) => SetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

        // １プレイヤーの２枚目のカードのフォーカスを外す
        GetCard(0, 1, (goCard) => ResetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

「　👆　これは」

新しいコード:

        // １プレイヤーの１枚目のカードにフォーカスを当てる
        GetCard(0, 0, (goCard) => SetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

        // １プレイヤーの右隣のカードへフォーカスを移します
        MoveFocusToNextCard(0, 0);
        yield return new WaitForSeconds(seconds);

        // １プレイヤーの２枚目のカードのフォーカスを外す
        GetCard(0, 1, (goCard) => ResetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

「　👆　こう書き直せるな」

「　『フォーカスされているカードはない』という状態を　有りにすれば、
『１枚目のカードにフォーカスを当てる』のも、
『１プレイヤーの右隣のカードへフォーカスを移します』で代用できるんじゃないの？」

    /// 
    /// プレイヤーが選択している場札は、先頭から何枚目
    /// 
    /// - 選択中の場札が無いなら、-1
    /// 
    int[] playsersFocusedCardIndex = { -1, -1 };

「　👆　こう書き直して……」

    /// 
    /// 隣のカードへフォーカスを移します
    /// 
    /// 
    /// 後ろ:0, 前:1
    void MoveFocusToNextCard(int player, int direction)
    {
        int previous;
        int current;

        switch (direction)
        {
            case 0:
                var length = goPlayersHandCards[player].Count;
                previous = playsersFocusedCardIndex[player];
                if (previous==-1)
                {
                    // 最後尾の外から、最後尾へ入ってくる
                    current = length - 1;
                }
                else
                {
                    current = previous + 1;
                }

                if (length <= current)
                {
                    return;
                }
                break;

            case 1:
                previous = playsersFocusedCardIndex[player];
                if (previous==-1)
                {
                    // 先頭の外から、先頭へ入ってくる
                    current = 0;
                }
                else
                {
                    current = previous - 1;
                }

                if (current < 0)
                {
                    return;
                }
                break;

            default:
                throw new Exception();
        }

        // 前にフォーカスしていたカードを、盤に下ろす
        var goPreviousCard = goPlayersHandCards[player][previous];
        ResetFocusHand(goPreviousCard);

        // 今回フォーカスするカードを持ち上げる
        var goCurrentCard = goPlayersHandCards[player][current];
        SetFocusHand(goCurrentCard);

        // 更新
        playsersFocusedCardIndex[player] = current;
    }

「　👆　こうかだぜ」

        for (int i=0; i<2; i++)
        {
            // １プレイヤーの右隣のカードへフォーカスを移します
            MoveFocusToNextCard(0, 0);
            yield return new WaitForSeconds(seconds);
        }

        // １プレイヤーの２枚目のカードのフォーカスを外す
        GetCard(0, 1, (goCard) => ResetFocusHand(goCard));
        yield return new WaitForSeconds(seconds);

「　👆　すると　こう書けるわけかだぜ。　便利になるな」

📅2023-01-29 sat 16:03

「　持ってる場札を、台札の上に置いたら、
場札は　どれをピックアップしている状態に戻るんだぜ？」

「　どれもピックアップしてないんじゃないの？」

「　じゃあ　また端っこから　ピックアップし直しかだぜ？」

「　それも不便だぜ」

「　じゃあ　抜いたカードの右隣を　ピックアップするようにしたらいいんじゃないの？」

「　右端のカードを抜いたんだったら　どうする？」

「　一番右端のカードを　ピックアップしたらいいのよ。
何もピックアップしないというのも　自然だけど」

📅2023-01-29 sat 16:21

    void Start()
    { // ... 略

        // ２プレイヤーが、場札の１枚目を抜いて、左の台札へ積み上げる
        MoveCardToCenterStackFromHand(
            player: 1, // ２プレイヤーが
            handIndex: 0, // 場札の１枚目から
            place: left // 左の
            );

        // １プレイヤーが、場札の１枚目を抜いて、右の台札へ積み上げる
        MoveCardToCenterStackFromHand(
            player: 0, // １プレイヤーが
            handIndex: 0, // 場札の１枚目から
            place: right // 右の
            );

        StartCoroutine("DoDemo");
    }

「　👆　既存のコードでは、任意の場所のカードを引き抜けたが、
これを　ピックアップしているカードを引き抜く　ように固定したいぜ」

    private void MoveCardToCenterStackFromHand(int player, int handIndex, int place)
    {
        var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
        goPlayersHandCards[player].RemoveAt(handIndex);

「　👆　つまり　handIndex 変数を廃止して、
playsersFocusedCardIndex[player] を参照するように　１本化したいぜ」

「　しろだぜ」

    private void MoveCardToCenterStackFromHand(int player, int place)
    {
        int handIndex = playsersFocusedCardIndex[player]; // 何枚目の場札をピックアップしているか
        if (handIndex < 0 || goPlayersHandCards[player].Count <= handIndex) // 範囲外は無視
        {
            return;
        }

        var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
        goPlayersHandCards[player].RemoveAt(handIndex);
        if (goPlayersHandCards[player].Count <= handIndex) // 範囲外アクセス防止対応
        {
            handIndex = goPlayersHandCards[player].Count - 1;
        }

        // ... 場札の位置調整が済んだ後で

        if (0 <= handIndex && handIndex < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 抜いたカードの右隣のカードを（有れば）ピックアップする
            var goNewPickupCard = goPlayersHandCards[player].ElementAt(handIndex);
            SetFocusHand(goNewPickupCard);
        }

「　👆　こう書きかえて」

    void Start()
    { // ... 略

        // １プレイヤーの先頭のカードへフォーカスを移します
        MoveFocusToNextCard(player: 0, direction: 0);
        // ２プレイヤーの先頭のカードへフォーカスを移します
        MoveFocusToNextCard(player: 1, direction: 0);

        // ２プレイヤーが、ピックアップ中の場札を抜いて、左の台札へ積み上げる
        MoveCardToCenterStackFromHand(
            player: 1, // ２プレイヤーが
            place: left // 左の
            );

        // １プレイヤーが、ピックアップ中の場札を抜いて、右の台札へ積み上げる
        MoveCardToCenterStackFromHand(
            player: 0, // １プレイヤーが
            place: right // 右の
            );

        StartCoroutine("DoDemo");
    }

「　👆　こうだぜ」

📅2023-01-29 sat 16:44

「　場札を並べ直すと、場札を全部　盤の上に置いてしまって　ピックアップを忘れているぜ」

    /// 
    /// 場札を並べなおすと、持ち上げていたカードを下ろしてしまうので、再度、持ち上げる
    /// 
    void ResumeCardPickup(int player)
    {
        int handIndex = playsersFocusedCardIndex[player]; // 何枚目の場札をピックアップしているか
        if (0 <= handIndex && handIndex < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 抜いたカードの右隣のカードを（有れば）ピックアップする
            var goNewPickupCard = goPlayersHandCards[player].ElementAt(handIndex);
            SetFocusHand(goNewPickupCard);
        }
    }

「　👆　再度、持ち上げるのを関数化して……」

    /// 
    /// 場札を並べる
    /// 
    void ArrangeHandCards(int player)
    { // ... 略

        // 場札を並べなおすと、持ち上げていたカードを下ろしてしまうので、再度、持ち上げる
        ResumeCardPickup(player);
    }

「　👆　場札の並べなおしメソッドに組み込んでしまおう。
他の箇所の既存の　持ち上げ直しコードは消すぜ」

📅2023-01-29 sat 17:07

    void Update()
    {
        // １プレイヤー
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: left // 左の
                );
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: right // 右の
                );
        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）左隣のカードをピックアップするように変えます
            MoveFocusToNextCard(0, 1);
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）右隣のカードをピックアップするように変えます
            MoveFocusToNextCard(0, 0);
        }

        // ２プレイヤー
        if (Input.GetKeyDown(KeyCode.W))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: right // 右の
                );
        }
        else if (Input.GetKeyDown(KeyCode.S))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: left // 左の
                );
        }
        else if (Input.GetKeyDown(KeyCode.A))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）左隣のカードをピックアップするように変えます
            MoveFocusToNextCard(1, 1);
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）右隣のカードをピックアップするように変えます
            MoveFocusToNextCard(1, 0);
        }
    }

「　👆　半分埋まったな」

「　２プレイヤーは　頭がひっくり返って　不利じゃない？」

「　上級者用のハンデに使えだぜ」

📅2023-01-29 sat 17:18

「　動かしてみると　配列の範囲を超えるエラーと　よく出会うので　リミットチェックを入れていくぜ」

    /// 
    /// 隣のカードへフォーカスを移します
    /// 
    /// 
    /// 後ろ:0, 前:1
    void MoveFocusToNextCard(int player, int direction)
    {
        int previous;
        int current;
        var length = goPlayersHandCards[player].Count;

        switch (direction)
        {
            // 後ろへ
            case 0:
                previous = playsersFocusedCardIndex[player];
                if (previous == -1)
                {
                    // （ピックアップしているカードが無いとき）先頭の外から、先頭へ入ってくる
                    current = 0;
                }
                else
                {
                    current = previous + 1;
                    if (length <= current)
                    {
                        // 範囲外は -1 ということにしておく
                        current = -1;
                    }
                }

                break;

            // 前へ
            case 1:
                previous = playsersFocusedCardIndex[player];
                if (previous == -1)
                {
                    // （ピックアップしているカードが無いとき）最後尾の外から、最後尾へ入ってくる
                    current = length - 1;
                }
                else
                {
                    current = previous - 1;
                    // - 1 になるケースもある
                }

                break;

            default:
                throw new Exception();
        }

        // 更新
        playsersFocusedCardIndex[player] = current;

        if (0 <= previous && previous < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 前にフォーカスしていたカードを、盤に下ろす
            var goPreviousCard = goPlayersHandCards[player][previous];
            ResetFocusHand(goPreviousCard);
        }

        if (0 <= current && current < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 今回フォーカスするカードを持ち上げる
            var goCurrentCard = goPlayersHandCards[player][current];
            SetFocusHand(goCurrentCard);
        }
    }

「　👆　こう」

📅2023-01-29 sat 17:40

「　右端の場札を　台札の上に置いたら、
何も場札を選択していない状態になるんだけど、
この瞬間、何ボタンを押したらいいのか　分かんなくなっちゃうのよね」

「　じゃあ、場札がある限り、必ず　なんらかの場札が１枚　ピックアップされている状態にした方が　いいのかだぜ？」

    /// 
    /// 隣のカードへフォーカスを移します
    /// 
    /// 
    /// 後ろ:0, 前:1
    void MoveFocusToNextCard(int player, int direction)
    {
        int previous = playsersFocusedCardIndex[player];
        int current;
        var length = goPlayersHandCards[player].Count;

        if (length < 1)
        {
            // 場札が無いなら、何もピックアップされていません
            current = -1;
        }
        else
        {
            switch (direction)
            {
                // 後ろへ
                case 0:
                    if (previous == -1 || length <= previous + 1)
                    {
                        // （ピックアップしているカードが無いとき）先頭の外から、先頭へ入ってくる
                        current = 0;
                    }
                    else
                    {
                        current = previous + 1;
                    }
                    break;

                // 前へ
                case 1:
                    if (previous == -1 || previous - 1 < 0)
                    {
                        // （ピックアップしているカードが無いとき）最後尾の外から、最後尾へ入ってくる
                        current = length - 1;
                    }
                    else
                    {
                        current = previous - 1;
                    }
                    break;

                default:
                    throw new Exception();
            }
        }

        // 更新
        playsersFocusedCardIndex[player] = current;

        if (0 <= previous && previous < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 前にフォーカスしていたカードを、盤に下ろす
            var goPreviousCard = goPlayersHandCards[player][previous];
            ResetFocusHand(goPreviousCard);
        }

        if (0 <= current && current < goPlayersHandCards[player].Count) // 範囲内なら
        {
            // 今回フォーカスするカードを持ち上げる
            var goCurrentCard = goPlayersHandCards[player][current];
            SetFocusHand(goCurrentCard);
        }
    }

「　👆　左右への移動は　右端が左端とつながっているようにループさせて」

    /// 
    /// 場札の好きなところから１枚抜いて、台札を１枚置く
    /// 
    /// 何番目のプレイヤー
    /// 右なら0、左なら1
    private void MoveCardToCenterStackFromHand(int player, int place)
    {
        int handIndex = playsersFocusedCardIndex[player]; // 何枚目の場札をピックアップしているか
        if (handIndex < 0 || goPlayersHandCards[player].Count <= handIndex) // 範囲外は無視
        {
            return;
        }

        var goCard = goPlayersHandCards[player].ElementAt(handIndex); // カードを１枚抜いて
        goPlayersHandCards[player].RemoveAt(handIndex);
        if (handIndex < 0 && 0 < goPlayersHandCards[player].Count)
        {
            handIndex = 0;
        }
        else if (goPlayersHandCards[player].Count <= handIndex) // 範囲外アクセス防止対応
        {
            // 一旦、最後尾へ
            handIndex = goPlayersHandCards[player].Count - 1;
        }
        // それでも範囲外なら、負の数
        playsersFocusedCardIndex[player] = handIndex; // 更新：何枚目の場札をピックアップしているか

// ... 略

「　👆　台札の移動は　場札のどれかを必ず選択しておくようにするぜ」

📅2023-01-29 sat 18:03

📅2023-01-31 mon 04:32

「　腰が痛くて　目が覚めたので　朝から練習しよ。
えーと　どこまで　やったっけ？」

「　👆　フーン。
何やってたかな。手札を、場札へ移動する動きも付けたいな。
デバッグ用に　スペース・キーに割り当てるか」

    void Update()
    { // ...

        // デバッグ用
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 両プレイヤーは手札から１枚抜いて、場札として置く
            for (var player=0; player<2; player++)
            {
                MoveCardsToHandFromPile(player, 1);
            }
        }    
    }

「　👆　こんなんでいいかな」

「　👆　よし、手札を場札へ　移動できるぜ」

「　操作方法を　画面に書き込むかな？」

「　👆　どうやって　白色を　透過させるんだぜ？」

📖 透過PNGの設定方法　Unity

「　👆　ゲーム・オブジェクトじゃなくて、画像素材側に設定するのかだぜ？」

「　👆　ウィンドウの縦幅を伸ばすと Apply ボタンが出てきた。気づかね～」

「　👆　べつに　白色が透過される様子もないぜ」

📖 unityで画像背景を透過させる方法が分かりません。
📖 Unityでテクスチャを透明にする

「　👆　調べても分からんので昔ながらの方法でやる。GIMP を使って、
PNG画像が RGB 形式で、データが　不透明度を表す A チャンネルを持ってないようなので、
アルファ・チャンネルを追加し……」

「　👆　マジックワンドを使って　白い所を選んで、 [Del] キーで消すぜ」

「　👆　画像を差し替えると　透過した」

「　👆　この Shader は Sprites/Diffuse でいいのか？
自分が何やってんのか　分からなくて　つらい」

📅2023-01-31 sat 06:12

「　👆　操作説明は　これぐらい　うるさく書いておけば　確かだろ。
邪魔くさいが……」

📅2023-01-31 sat 06:38

「　👆　やっぱ　RGB値を　加算したいな……。
シェーダーの書き方を調べるか」

📖 【Unity UI】uGUIで色を加算合成する方法

「　👆　日本人の薄っぺらい記事なんか読んでも　さっぱり分からんな　公式読むか」

📖 カスタムシェーダーの基礎
📖 シェーダーの作成

「　👆　HLSL という書き方を覚えればいいらしいぜ」

「　数十分で終わるレベルではないので　パス」

📅2023-01-31 sat 06:58

「　次は、ゲームのルールを組み込んでいくか」

「　しかし、今のプログラミングの書き方では　ルール・ベースで書きにくい……」

「　👆　いったん　画面関係の変数は　GameViewModel クラスを新しく作って　そっちへ移し……」

「　👆　GameManager.cs の方では　GameViewModel インスタンスを使うように書き直し……」

「　👆　変数名の頭に go と付けたやつは　GameObject　なんで、
画面に関係するものは全部　GameViewModel　クラスへ　追いやるぜ」

「　👆　配列の長さを取りたいときは、 GetCenterStackCardsLength() メソッドを使うようにする。
これを　ラッピング・メソッド（Wrapping method）　という」

「　👆　こうやって、 GameManager の方は、　ゲーム・オブジェクトをいじらなくても、
player: 0 とか、 numberOfCards: 5 とか、命令だけ書けばいいような　見た目に変えていくぜ」

📅2023-01-31 sat 07:33

「　全部　ラッピングするの　時間かかるから　今朝は　ここまで」

📅2023-01-31 sat 08:04

📅2023-01-31 mon 23:34

「　眠りが覚めた。ちょっと練習しよ」

📅2023-02-01 sat 23:34 start

「　全体的に　書きかえた。また寝よ」

📅2023-02-01 sat 03:54 end

📅2023-02-01 mon 21:04

「　👆　大改造した」

「　いっぱい増えてるぜ」

「　会社でやってはいけないことの１つが　大改造よ。
コード・レビュー受け付けられないから　没になるのよ」

「　👆　Unity に　ゲームの基本機能が　足りな過ぎるので　タイムライン機能を自作した」

「　Unity にも　あるかも知らんのに」

「　👆　Command （コマンド）というのは、プレイヤーができる操作だな。
中を見てみよう」

📄 Assets/Scripts/Models/Timeline/Commands/ICommand.cs file:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;

    /// 
    /// コマンド
    /// 
    interface ICommand
    {
        /// 
        /// コマンド実行
        /// 
        /// ゲームの内部状態（編集可能）
        /// 画面表示の状態（編集可能）
        void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel);
    }
}

「　👆　『コマンドを実行すると、　ゲームの内部状態　と、　画面表示の状態　が変わる』、ということを書いている」

📄 Assets/Scripts/Models/Timeline/Commands/MoveCardsToHandFromPile.cs file:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;

    /// 
    /// ｎプレイヤーの手札から場札へ、ｍ枚のカードを移動
    /// 
    class MoveCardsToHandFromPile : ICommand
    {
        // - その他（生成）

        /// 
        /// 生成
        /// 
        /// ｎプレイヤー
        /// カードがｍ枚
        internal MoveCardsToHandFromPile(int player, int numberOfCards)
        {
            Player = player;
            NumberOfCards = numberOfCards;
        }

        // - プロパティ

        int Player { get; set; }
        int NumberOfCards { get; set; }

        // - メソッド

        /// 
        /// 手札の上の方からｎ枚抜いて、場札の後ろへ追加する
        /// 
        /// - 画面上の場札は位置調整される
        /// 
        public void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel)
        {
            // 手札の上の方からｎ枚抜いて、場札へ移動する
            var length = gameModelBuffer.IdOfCardsOfPlayersPile[Player].Count; // 手札の枚数
            if (NumberOfCards <= length)
            {
                // もし、場札が空っぽのところへ、手札を配ったのなら、先頭の場札をピックアップする
                if (gameModelBuffer.IndexOfFocusedCardOfPlayers[Player] == -1)
                {
                    gameModelBuffer.IndexOfFocusedCardOfPlayers[Player] = 0;
                }

                GameModel gameModel = new GameModel(gameModelBuffer);
                var startIndex = length - NumberOfCards;

                gameModelBuffer.MoveCardsToHandFromPile(Player, startIndex, NumberOfCards);

                gameViewModel.ArrangeHandCards(gameModel, Player);
            }
        }
    }
}

「　👆　コマンドの中身は　こんな感じだぜ」

「　さっぱり分からん」

📄 Assets/Scripts/Models/Timeline/Commands/MoveCardsToPileFromCenterStacks.cs file:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;
    using System;

    /// 
    /// 右（または左）側の台札１枚を、手札へ移動する
    /// 
    class MoveCardsToPileFromCenterStacks : ICommand
    {
        // - 生成

        internal MoveCardsToPileFromCenterStacks(int place)
        {
            this.Place = place;
        }

        // - プロパティ

        int Place { get; set; }

        // - メソッド

        /// 
        /// 台札を、手札へ移動する
        /// 
        /// - ゲーム開始時に使う
        /// 
        /// 右:0, 左:1
        public void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel)
        {
            // 台札の一番上（一番後ろ）のカードを１枚抜く
            var numberOfCards = 1;
            var length = gameModelBuffer.IdOfCardsOfCenterStacks[Place].Count; // 台札の枚数
            if (1 <= length)
            {
                var startIndex = length - numberOfCards;
                var idOfCard = gameModelBuffer.IdOfCardsOfCenterStacks[Place][startIndex];
                gameModelBuffer.RemoveCardAtOfCenterStack(Place, startIndex);

                // 黒いカードは１プレイヤー、赤いカードは２プレイヤー
                int player;
                float angleY;
                var goCard = GameObjectStorage.PlayingCards[idOfCard];
                if (goCard.name.StartsWith("Clubs") || goCard.name.StartsWith("Spades"))
                {
                    player = 0;
                    angleY = 180.0f;
                }
                else if (goCard.name.StartsWith("Diamonds") || goCard.name.StartsWith("Hearts"))
                {
                    player = 1;
                    angleY = 0.0f;
                }
                else
                {
                    throw new Exception();
                }

                // プレイヤーの手札を積み上げる
                gameModelBuffer.AddCardOfPlayersPile(player, idOfCard);
                gameViewModel.SetPosRot(idOfCard, gameViewModel.pileCardsX[player], gameViewModel.pileCardsY[player], gameViewModel.pileCardsZ[player], angleY: angleY, angleZ: 180.0f);
                gameViewModel.pileCardsY[player] += 0.2f;
            }
        }
    }
}

「　👆　説明するの　めんどくさいんで　感じろだぜ」

「　わらう」

📄 Assets/Scripts/Models/Timeline/Commands/MoveCardToCenterStackFromHand.cs file:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;

    /// 
    /// ｎプレイヤーがピックアップしている場札を、右（または左）の台札へ移動する
    /// 
    class MoveCardToCenterStackFromHand : ICommand
    {
        // - 生成

        internal MoveCardToCenterStackFromHand(int player, int place)
        {
            this.Player = player;
            this.Place = place;
        }

        // - プロパティ

        int Player { get; set; }
        int Place { get; set; }

        // - メソッド

        /// 
        /// ｎプレイヤーがピックアップしている場札を、右（または左）の台札へ移動する
        /// 
        /// 何番目のプレイヤー
        /// 右なら0、左なら1
        public void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel)
        {
            var gameModel = new GameModel(gameModelBuffer);

            // ピックアップしているカードがあるか？
            GetIndexOfFocusedHandCard(
                gameModelBuffer: gameModelBuffer,
                player: Player,
                (indexOfFocusedHandCard) =>
                {
                    RemoveAtOfHandCard(
                        gameModelBuffer: gameModelBuffer,
                        gameViewModel: gameViewModel,
                        player: Player,
                        place: Place,
                        indexOfHandCardToRemove: indexOfFocusedHandCard,
                        setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                        {
                            gameModelBuffer.IndexOfFocusedCardOfPlayers[Player] = indexOfNextFocusedHandCard; // 更新：何枚目の場札をピックアップしているか

                            // 場札の位置調整
                            gameViewModel.ArrangeHandCards(
                                gameModel: gameModel,
                                player: Player);
                        });
                });
        }

        private static void GetIndexOfFocusedHandCard(GameModelBuffer gameModelBuffer, int player, LazyArgs.SetValue setIndex)
        {
            int handIndex = gameModelBuffer.IndexOfFocusedCardOfPlayers[player]; // 何枚目の場札をピックアップしているか
            if (handIndex < 0 || gameModelBuffer.IdOfCardsOfPlayersHand[player].Count <= handIndex) // 範囲外は無視
            {
                return;
            }

            setIndex(handIndex);
        }


        /// 
        /// 台札を抜く
        /// 
        /// 
        /// 
        /// 
        private static void RemoveAtOfHandCard(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel, int player, int place, int indexOfHandCardToRemove, LazyArgs.SetValue setIndexOfNextFocusedHandCard)
        {
            // 抜く前の場札の数
            var lengthBeforeRemove = gameModelBuffer.IdOfCardsOfPlayersHand[player].Count;
            if (indexOfHandCardToRemove < 0 || lengthBeforeRemove <= indexOfHandCardToRemove)
            {
                // 抜くのに失敗
                return;
            }

            // 抜いた後の場札の数
            var lengthAfterRemove = lengthBeforeRemove - 1;

            // 抜いた後の次のピックアップするカードが先頭から何枚目か、先に算出
            int indexOfNextFocusedHandCard;
            if (lengthAfterRemove <= indexOfHandCardToRemove) // 範囲外アクセス防止対応
            {
                // 一旦、最後尾へ
                indexOfNextFocusedHandCard = lengthAfterRemove - 1;
            }
            else
            {
                // そのまま
                indexOfNextFocusedHandCard = indexOfHandCardToRemove;
            }

            var goCard = gameModelBuffer.IdOfCardsOfPlayersHand[player][indexOfHandCardToRemove]; // 場札を１枚抜いて
            gameModelBuffer.RemoveCardAtOfPlayerHand(player, indexOfHandCardToRemove);

            AddCardOfCenterStack2(gameModelBuffer, gameViewModel, goCard, place); // 台札
            setIndexOfNextFocusedHandCard(indexOfNextFocusedHandCard);
        }

        private static void AddCardOfCenterStack2(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel, IdOfPlayingCards idOfCard, int place)
        {
            var gameModel = new GameModel(gameModelBuffer);

            // 手ぶれ
            var (shakeX, shakeZ, shakeAngleY) = gameViewModel.MakeShakeForCenterStack(place);

            // 台札の次の天辺（一番後ろ）のカードの中心座標 X, Z
            var (nextTopX, nextTopZ) = gameViewModel.GetXZOfNextCenterStackCard(gameModel, place);

            // 台札の捻り
            var goCard = GameObjectStorage.PlayingCards[idOfCard];
            float nextAngleY = goCard.transform.rotation.eulerAngles.y;
            var length = gameModel.GetLengthOfCenterStackCards(place);
            if (length < 1)
            {
            }
            else
            {
                nextAngleY += shakeAngleY;
            }

            gameModelBuffer.AddCardOfCenterStack(place, idOfCard); // 台札として置く

            // 台札の位置をセット
            gameViewModel.SetPosRot(idOfCard, nextTopX + shakeX, gameViewModel.centerStacksY[place], nextTopZ + shakeZ, angleY: nextAngleY);

            // 次に台札に積むカードの高さ
            gameViewModel.centerStacksY[place] += 0.2f;
        }
    }
}

「　👆　説明がないのなら　コードも貼らなくていいのでは？」

📄 Assets/Scripts/Models/Timeline/Commands/MoveFocusToNextCard.cs file:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;
    using System;

    /// 
    /// ｎプレイヤーは、右（または左）隣のカードへ、ピックアップを移動します
    /// 
    class MoveFocusToNextCard : ICommand
    {
        // - 生成

        internal MoveFocusToNextCard(int player, int direction, LazyArgs.SetValue setIndexOfNextFocusedHandCard)
        {
            this.Player = player;
            this.Direction = direction;
            this.SetIndexOfNextFocusedHandCard = setIndexOfNextFocusedHandCard;
        }

        // - プロパティ

        int Player { get; set; }
        int Direction { get; set; }
        LazyArgs.SetValue SetIndexOfNextFocusedHandCard { get; set; }

        // - メソッド

        /// 
        /// ｎプレイヤーは、右（または左）隣のカードへ、ピックアップを移動します
        /// 
        /// 
        /// 後ろ:0, 前:1
        public void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel)
        {
            GameModel gameModel = new GameModel(gameModelBuffer);
            int indexOfFocusedHandCard = gameModelBuffer.IndexOfFocusedCardOfPlayers[Player];

            int current;
            var length = gameModelBuffer.IdOfCardsOfPlayersHand[Player].Count;

            if (length < 1)
            {
                // 場札が無いなら、何もピックアップされていません
                current = -1;
            }
            else
            {
                switch (Direction)
                {
                    // 後ろへ
                    case 0:
                        if (indexOfFocusedHandCard == -1 || length <= indexOfFocusedHandCard + 1)
                        {
                            // （ピックアップしているカードが無いとき）先頭の外から、先頭へ入ってくる
                            current = 0;
                        }
                        else
                        {
                            current = indexOfFocusedHandCard + 1;
                        }
                        break;

                    // 前へ
                    case 1:
                        if (indexOfFocusedHandCard == -1 || indexOfFocusedHandCard - 1 < 0)
                        {
                            // （ピックアップしているカードが無いとき）最後尾の外から、最後尾へ入ってくる
                            current = length - 1;
                        }
                        else
                        {
                            current = indexOfFocusedHandCard - 1;
                        }
                        break;

                    default:
                        throw new Exception();
                }
            }

            SetIndexOfNextFocusedHandCard(current);

            if (0 <= indexOfFocusedHandCard && indexOfFocusedHandCard < gameModelBuffer.IdOfCardsOfPlayersHand[Player].Count) // 範囲内なら
            {
                // 前にフォーカスしていたカードを、盤に下ろす
                gameViewModel.PutDownCardOfHand(gameModel, Player, indexOfFocusedHandCard);
            }

            if (0 <= current && current < gameModelBuffer.IdOfCardsOfPlayersHand[Player].Count) // 範囲内なら
            {
                // 今回フォーカスするカードを持ち上げる
                gameViewModel.PickupCardOfHand(gameModel, Player, current);
            }
        }
    }
}

「　👆　まあ、　だから　ゲームの状態と、　画面の表示を　変更するのが　コマンドだぜ」

「　👆　そして　コマンドに　時間を付けて、　時限式で　実行すりゃいいんだぜ。
ソースを見てみよう」

📄 Assets/Scripts/Models/Timeline/TimedItem.cs file:

namespace Assets.Scripts.Models.Timeline
{
    using Assets.Scripts.Models.Timeline.Commands;

    /// 
    /// 指定した時間と、そのとき実行されるコマンドのペア
    /// 
    class TimedItem
    {
        // - その他（生成）

        internal TimedItem(float seconds, ICommand command)
        {
            this.Seconds = seconds;
            this.Command = command;
        }

        // - プロパティ

        internal float Seconds { get; private set; }
        internal ICommand Command { get; private set; }
    }
}

「　👆　タイムラインの上に置いてあるコマンドだぜ。
『音符』みたいなもんだぜ。　感じろ」

📄 Assets/Scripts/Models/Timeline/Model.cs file:

namespace Assets.Scripts.Models.Timeline
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Models.Timeline.Commands;
    using Assets.Scripts.Views;
    using System.Collections.Generic;

    /// 
    /// タイムライン・モデル
    /// 
    internal class Model
    {
        // - プロパティ

        List timedItems = new();

        internal List TimedItems
        {
            get
            {
                return this.timedItems;
            }
        }

        // - メソッド

        /// 
        /// 追加
        /// 
        /// 実行される時間（秒）
        /// コマンド
        internal void Add(float seconds, ICommand command)
        {
            this.TimedItems.Add(new TimedItem(seconds,command));
        }

        /// 
        /// コマンドを消化
        /// 
        /// ゲーム内消費時間（秒）
        /// ゲームの内部状態（編集可能）
        /// 画面表示の状態（編集可能）
        internal void DoIt(float elapsedSeconds, GameModelBuffer gameModelBuffer, GameViewModel gameViewModel)
        {
            if (0 < timedItems.Count)
            {
                var timedCommand = timedItems[0];

                while (timedCommand.Seconds <= elapsedSeconds)
                {
                    // 消化
                    timedItems.RemoveAt(0);
                    timedCommand.Command.DoIt(gameModelBuffer, gameViewModel);

                    if (0 < timedItems.Count)
                    {
                        timedCommand = timedItems[0];
                    }
                    else
                    {
                        break;
                    }
                }
            }
        }
    }
}

「　👆　タイムラインは、『音符』のようなものが記憶されていて、時間が来たら実行される。
『楽譜』みたいなもんだぜ。　感じろ」

「　👆　ゲームの状態を記憶しているのは、 GameModelBuffer インスタンスだぜ。
GameModel は、読み取り専用の GameModelBuffer だぜ」

📄 Assets/Scripts/Models/GameModel.cs file:

namespace Assets.Scripts.Models
{
    using System.Collections.Generic;

    /// 
    /// ゲーム・モデル
    /// 
    /// - 読み取り専用。(Immutable)
    /// 
    class GameModel
    {
        GameModelBuffer gameModelBuffer;

        public GameModel(GameModelBuffer gameModel)
        {
            this.gameModelBuffer = gameModel;
        }

        /// 
        /// 右（または左）の天辺の台札
        /// 
        /// 右:0, 左:1
        /// 
        internal IdOfPlayingCards GetLastCardOfCenterStack(int place)
        {
            var length = this.GetLengthOfCenterStackCards(place);
            var startIndex = length - 1;
            return this.gameModelBuffer.IdOfCardsOfCenterStacks[place][startIndex]; // 最後のカード
        }

        /// 
        /// ｎプレイヤーが選択している場札は、先頭から何枚目
        /// 
        /// - 選択中の場札が無いなら、-1
        /// 
        /// プレイヤー
        internal int GetIndexOfFocusedCardOfPlayer(int player)
        {
            return this.gameModelBuffer.IndexOfFocusedCardOfPlayers[player];
        }

        /// 
        /// 右（または左）の台札の枚数
        /// 
        /// 右:0, 左:1
        internal int GetLengthOfCenterStackCards(int place)
        {
            return this.gameModelBuffer.IdOfCardsOfCenterStacks[place].Count;
        }

        /// 
        /// ｎプレイヤーの、場札の枚数
        /// 
        /// プレイヤー
        /// 
        internal int GetLengthOfPlayerHandCards(int player)
        {
            return this.gameModelBuffer.IdOfCardsOfPlayersHand[player].Count;
        }

        /// 
        /// ｎプレイヤーの、場札をリストで取得
        /// 
        /// プレイヤー
        /// 
        internal List GetCardsOfPlayerHand(int player)
        {
            return this.gameModelBuffer.IdOfCardsOfPlayersHand[player];
        }

        /// 
        /// ｎプレイヤーの、ｍ枚目の場札を取得
        /// 
        /// 
        /// 
        /// 
        internal IdOfPlayingCards GetCardAtOfPlayerHand(int player, int handIndex)
        {
            return this.gameModelBuffer.IdOfCardsOfPlayersHand[player][handIndex];
        }
    }
}

「　👆　GameModel は、GameModelBuffer を包んでるわけだな」

📄 Assets/Scripts/Models/GameModelBuffer.cs file:

namespace Assets.Scripts.Models
{
    using System.Collections.Generic;

    /// 
    /// ゲームの状態
    /// 
    /// - 編集可能
    /// 
    public class GameModelBuffer
    {
        // - プロパティ

        /// 
        /// ｎプレイヤーが選択している場札は、先頭から何枚目
        /// 
        /// - 選択中の場札が無いなら、-1
        /// 
        internal int[] IndexOfFocusedCardOfPlayers { get; set; } = { -1, -1 };

        /// 
        /// 手札
        /// 
        /// - プレイヤー側で積んでる札
        /// - 0: １プレイヤー（黒色）
        /// - 1: ２プレイヤー（黒色）
        /// 
        internal List> IdOfCardsOfPlayersPile { get; set; } = new() { new(), new() };

        /// 
        /// 場札
        /// 
        /// - プレイヤー側でオープンしている札
        /// - 0: １プレイヤー（黒色）
        /// - 1: ２プレイヤー（黒色）
        /// 
        internal List> IdOfCardsOfPlayersHand { get; set; } = new() { new(), new() };

        /// 
        /// 台札
        /// 
        /// - 画面中央に積んでいる札
        /// - 0: 右
        /// - 1: 左
        /// 
        internal List> IdOfCardsOfCenterStacks { get; set; } = new() { new(), new() };

        /// 
        /// 台札を削除
        /// 
        /// 
        /// 
        internal void RemoveCardAtOfCenterStack(int place, int startIndex)
        {
            this.IdOfCardsOfCenterStacks[place].RemoveAt(startIndex);
        }

        /// 
        /// 台札を追加
        /// 
        /// 
        /// 
        internal void AddCardOfCenterStack(int place, IdOfPlayingCards idOfCard)
        {
            this.IdOfCardsOfCenterStacks[place].Add(idOfCard);
        }

        /// 
        /// 手札を追加
        /// 
        /// 
        /// 
        internal void AddCardOfPlayersPile(int player, IdOfPlayingCards idOfCard)
        {
            this.IdOfCardsOfPlayersPile[player].Add(idOfCard);
        }

        /// 
        /// 手札を削除
        /// 
        /// 
        /// 
        /// 
        internal void RemoveRangeCardsOfPlayerPile(int player, int startIndex, int numberOfCards)
        {
            this.IdOfCardsOfPlayersPile[player].RemoveRange(startIndex, numberOfCards);
        }

        /// 
        /// 場札を追加
        /// 
        /// 
        /// 
        internal void AddRangeCardsOfPlayerHand(int player, List idOfCards)
        {
            this.IdOfCardsOfPlayersHand[player].AddRange(idOfCards);
        }

        /// 
        /// 場札を削除
        /// 
        /// 
        /// 
        internal void RemoveCardAtOfPlayerHand(int player, int handIndex)
        {
            this.IdOfCardsOfPlayersHand[player].RemoveAt(handIndex);
        }

        /// 
        /// 手札から場札へ移動
        /// 
        /// 
        /// 
        /// 
        internal void MoveCardsToHandFromPile(int player, int startIndex, int numberOfCards)
        {
            var idOfCards = this.IdOfCardsOfPlayersPile[player].GetRange(startIndex, numberOfCards);

            this.RemoveRangeCardsOfPlayerPile(player, startIndex, numberOfCards);
            this.AddRangeCardsOfPlayerHand(player, idOfCards);
        }
    }
}

「　👆　GameModelBuffer は、ゲームを時間で切った断面図みたいなもんだぜ」

「　じゃあ　スナップショットか？」

📄 Assets/Scripts/Models/IdOfPlayingCards.cs file:

namespace Assets.Scripts.Models
{
    /// 
    /// トランプのカード
    /// 
    /// - ジョーカーを除く
    /// 
    internal enum IdOfPlayingCards
    {
        Clubs1,
        Clubs2,
        Clubs3,
        Clubs4,
        Clubs5,
        Clubs6,
        Clubs7,
        Clubs8,
        Clubs9,
        Clubs10,
        Clubs11,
        Clubs12,
        Clubs13,

        Diamonds1,
        Diamonds2,
        Diamonds3,
        Diamonds4,
        Diamonds5,
        Diamonds6,
        Diamonds7,
        Diamonds8,
        Diamonds9,
        Diamonds10,
        Diamonds11,
        Diamonds12,
        Diamonds13,

        Hearts1,
        Hearts2,
        Hearts3,
        Hearts4,
        Hearts5,
        Hearts6,
        Hearts7,
        Hearts8,
        Hearts9,
        Hearts10,
        Hearts11,
        Hearts12,
        Hearts13,

        Spades1,
        Spades2,
        Spades3,
        Spades4,
        Spades5,
        Spades6,
        Spades7,
        Spades8,
        Spades9,
        Spades10,
        Spades11,
        Spades12,
        Spades13,
    }
}

「　👆　トランプのカードの Id を、 enum型で作っておくぜ」

📅2023-02-01 sat 22:04

「　👆　ビューは　画面表示関連だぜ」

📄 Assets/Scripts/Views/GameObjectStorage.cs file:

namespace Assets.Scripts.Views
{
    using Assets.Scripts.Models;
    using System.Collections.Generic;
    using UnityEngine;

    /// 
    /// ゲーム・オブジェクトと、その Id の紐づけ
    /// 
    static class GameObjectStorage
    {
        internal static Dictionary PlayingCards { get; private set; } =  new();

        internal static void Add(IdOfPlayingCards cardId, GameObject goCard)
        {
            PlayingCards.Add(cardId, goCard);
        }
    }
}

「　👆　ゲーム・オブジェクトを、 Id で　すぐ取り出せる仕組みを作っておくぜ。
GameObject.Find( ... ) は　処理が重たいらしいしな」

📄 Assets/Scripts/Views/GameViewModel.cs file:

namespace Assets.Scripts.Views
{
    using Assets.Scripts.Models;
    using System;
    using UnityEngine;

    /// 
    /// 画面表示関連
    /// 
    /// 西端: -62.0f
    /// 東端: 62.0f
    /// 
    public class GameViewModel
    {
        // - プロパティー

        /// 
        /// 底端
        /// 
        /// - `0.0f` は盤
        /// 
        internal readonly float minY = 0.5f;

        internal readonly float[] handCardsZ = new[] { -28.0f, 42.0f };

        // 手札（プレイヤー側で伏せて積んでる札）
        internal readonly float[] pileCardsX = new[] { 40.0f, -40.0f }; // 端っこは 62.0f, -62.0f
        internal readonly float[] pileCardsY = new[] { 0.5f, 0.5f };
        internal readonly float[] pileCardsZ = new[] { -6.5f, 16.0f };

        // 台札
        internal float[] centerStacksX = { 15.0f, -15.0f };

        /// 
        /// 台札のY座標
        /// 
        /// - 右が 0、左が 1
        /// - 0.0f は盤なので、それより上にある
        /// 
        internal float[] centerStacksY = { 0.5f, 0.5f };
        internal float[] centerStacksZ = { 2.5f, 9.0f };

        // - メソッド

        /// 
        /// 台札の次の天辺の位置
        /// 
        /// 
        /// 
        internal (float, float) GetXZOfNextCenterStackCard(GameModel gameModel, int place)
        {
            var length = gameModel.GetLengthOfCenterStackCards(place);
            if (length < 1)
            {
                // 床上
                var nextTopX2 = this.centerStacksX[place];
                var nextTopZ2 = this.centerStacksZ[place];
                return (nextTopX2, nextTopZ2);
            }

            // 台札の次の天辺の位置
            var idOfLastCard = gameModel.GetLastCardOfCenterStack(place); // 天辺（最後）のカード
            var goLastCard = GameObjectStorage.PlayingCards[idOfLastCard];
            var nextTopX = (this.centerStacksX[place] - goLastCard.transform.position.x) / 2 + this.centerStacksX[place];
            var nextTopZ = (this.centerStacksZ[place] - goLastCard.transform.position.z) / 2 + this.centerStacksZ[place];
            return (nextTopX, nextTopZ);
        }

        /// 
        /// 場札を持ち上げる
        /// 
        /// 
        /// 
        internal void PickupCardOfHand(GameModel gameModel, int player, int handIndesx)
        {
            var idOfFocusedHandCard = gameModel.GetCardAtOfPlayerHand(player, handIndesx);

            var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
            var rotateY = -5; // -5°傾ける
            var rotateZ = -5; // -5°傾ける

            var goCard = GameObjectStorage.PlayingCards[idOfFocusedHandCard];
            goCard.transform.position = new Vector3(goCard.transform.position.x, goCard.transform.position.y + liftY, goCard.transform.position.z);
            goCard.transform.rotation = Quaternion.Euler(goCard.transform.rotation.eulerAngles.x, goCard.transform.rotation.eulerAngles.y + rotateY, goCard.transform.eulerAngles.z + rotateZ);
        }

        /// 
        /// ピックアップしているカードを場に戻す
        /// 
        /// 
        internal void PutDownCardOfHand(GameModel gameModel, int player, int handIndex)
        {
            var idOfCard = gameModel.GetCardAtOfPlayerHand(player, handIndex);

            var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
            var rotateY = -5; // -5°傾ける
            var rotateZ = -5; // -5°傾ける

            // 逆をする
            liftY = -liftY;
            rotateY = -rotateY;
            rotateZ = -rotateZ;

            var goCard = GameObjectStorage.PlayingCards[idOfCard];
            goCard.transform.position = new Vector3(goCard.transform.position.x, goCard.transform.position.y + liftY, goCard.transform.position.z);
            goCard.transform.rotation = Quaternion.Euler(goCard.transform.rotation.eulerAngles.x, goCard.transform.rotation.eulerAngles.y + rotateY, goCard.transform.eulerAngles.z + rotateZ);
        }

        /// 
        /// 場札を並べる
        /// 
        /// - 左端は角度で言うと 112.0f
        /// 
        internal void ArrangeHandCards(GameModel gameModel, int player)
        {
            int handIndex = gameModel.GetIndexOfFocusedCardOfPlayer(player);

            // 25枚の場札が並べるように調整してある

            int numberOfCards = gameModel.GetLengthOfPlayerHandCards(player); // 場札の枚数
            if (numberOfCards < 1)
            {
                return; // 何もしない
            }

            float cardAngleZ = -5; // カードの少しの傾き

            int range = 200; // 半径。大きな円にするので、中心を遠くに離したい
            int offsetCircleCenterZ; // 中心位置の調整

            float angleY;
            float playerTheta;
            float angleStep = -1.83f;
            float startTheta = (numberOfCards * Mathf.Abs(angleStep) / 2 - Mathf.Abs(angleStep) / 2 + 90.0f) * Mathf.Deg2Rad;
            float thetaStep = angleStep * Mathf.Deg2Rad; ; // 時計回り

            float ox = 0.0f;
            float oz = this.handCardsZ[player];

            switch (player)
            {
                case 0:
                    // １プレイヤー
                    angleY = 180.0f;
                    playerTheta = 0;
                    offsetCircleCenterZ = -190;
                    break;

                case 1:
                    // ２プレイヤー
                    angleY = 0.0f;
                    playerTheta = 180 * Mathf.Deg2Rad;
                    offsetCircleCenterZ = 188;  // カメラのパースペクティブが付いているから、目視で調整
                    break;

                default:
                    throw new Exception();
            }

            float theta = startTheta;
            foreach (var goCard in gameModel.GetCardsOfPlayerHand(player))
            {
                float x = range * Mathf.Cos(theta + playerTheta) + ox;
                float z = range * Mathf.Sin(theta + playerTheta) + oz + offsetCircleCenterZ;

                SetPosRot(goCard, x, this.minY, z, angleY: angleY, angleZ: cardAngleZ);
                theta += thetaStep;
            }

            // 場札を並べなおすと、持ち上げていたカードを下ろしてしまうので、再度、持ち上げる
            this.ResumeCardPickup(gameModel, player);
        }

        /// 
        /// 場札を並べなおすと、持ち上げていたカードを下ろしてしまうので、再度、持ち上げる
        /// 
        private void ResumeCardPickup(GameModel gameModel, int player)
        {
            int handIndex = gameModel.GetIndexOfFocusedCardOfPlayer(player);

            if (0 <= handIndex && handIndex < gameModel.GetLengthOfPlayerHandCards(player)) // 範囲内なら
            {
                // 抜いたカードの右隣のカードを（有れば）ピックアップする
                this.PickupCardOfHand(gameModel, player, handIndex);
            }
        }

        /// 
        /// カードの位置と　捻りの設定
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// Update関数の中でないと役に立たない
        internal void SetPosRot(IdOfPlayingCards idOfCard, float x, float y, float z, float angleY = 180.0f, float angleZ = 0.0f, float motionProgress = 1.0f)
        {
            var goCard = GameObjectStorage.PlayingCards[idOfCard];
            var beginPos = goCard.transform.position;
            var endPos = new Vector3(x, y, z);
            goCard.transform.position = Vector3.Lerp(beginPos, endPos, motionProgress);

            goCard.transform.rotation = Quaternion.Euler(0, angleY, angleZ);
        }

        /// 
        /// ぴったり積むと不自然だから、X と Z を少しずらすための仕組み
        /// 
        /// - １プレイヤー、２プレイヤーのどちらも右利きと仮定
        /// 
        /// 
        /// 
        internal (float, float, float) MakeShakeForCenterStack(int player)
        {
            // １プレイヤーから見て。左上にずれていくだろう
            var left = -1.5f;
            var right = 0.5f;
            var bottom = -0.5f;
            var top = 1.5f;
            var angleY = UnityEngine.Random.Range(-10, 40); // 反時計回りに大きく捻りそう

            switch (player)
            {
                case 0:
                    return (UnityEngine.Random.Range(left, right), UnityEngine.Random.Range(bottom, top), angleY);

                case 1:
                    return (UnityEngine.Random.Range(-right, -left), UnityEngine.Random.Range(-top, -bottom), angleY);

                default:
                    throw new Exception();
            }
        }
    }
}

「　👆　ゲーム・ビュー・モデルは　画面の表示が　どんな感じになってるか記憶したり、編集したりしているな」

「　👆　一番上の階層のスクリプトは、整理できてないものが残っている」

「　目立つんだから、重要なものを置けだぜ」

📄 Assets/Scripts/PlayingCard.cs file:

using UnityEngine;

public class PlayingCard : MonoBehaviour
{
    // Start is called before the first frame update
    void Start()
    {

    }

    // Update is called once per frame
    void Update()
    {

    }

    // 今回は使わない
    //
    ///// 
    ///// マウスボタン押下時
    ///// 
    //private void OnMouseDown()
    //{
    //    // 裏返します
    //    var oldZ = transform.rotation.eulerAngles.z; // 度数法
    //    transform.rotation = Quaternion.Euler(0, 0, oldZ + 180); // 180°回転
    //}
}

「　👆　PlayingCard.cs は、神経衰弱ゲームのとき使っていたが、スピードでは使っていないぜ」

「　じゃあ　消しなさいよ！」

📄 Assets/Scripts/LazyArgs.cs file:

namespace Assets.Scripts
{
    /// 
    /// コーディングのテクニックのための仕込み
    /// 
    internal class LazyArgs
    {
        public delegate void Action();
        public delegate void SetValue(T value);
    }
}

「　👆　LazyArgs.cs は、コードを上手く書くテクニックに使うだけなんで、気にしなくていい」

📄 Assets/Scripts/GameManager.cs file:

using Assets.Scripts.Models;
using Assets.Scripts.Views;
using System;
using System.Linq;
using UnityEngine;
using Commands = Assets.Scripts.Models.Timeline.Commands;
using ModelsOfTimeline = Assets.Scripts.Models.Timeline;

/// 
/// ゲーム・マネージャー
/// 
/// - スピードは、日本と海外で　ルールとプレイング・スタイルに違いがあるので、用語に統一感はない
/// 
public class GameManager : MonoBehaviour
{
    ModelsOfTimeline.Model commandStorage;
    GameModelBuffer gameModelBuffer;
    GameModel gameModel;
    GameViewModel gameViewModel;

    // ゲーム内単位時間
    float unitSeconds = 1.0f / 60.0f;
    // ゲーム内経過時間
    float elapsedSeconds = 0.0f;

    // Start is called before the first frame update
    void Start()
    {
        // 全てのカードのゲーム・オブジェクトを、IDに紐づける
        GameObjectStorage.Add(IdOfPlayingCards.Clubs1, GameObject.Find($"Clubs 1"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs2, GameObject.Find($"Clubs 2"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs3, GameObject.Find($"Clubs 3"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs4, GameObject.Find($"Clubs 4"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs5, GameObject.Find($"Clubs 5"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs6, GameObject.Find($"Clubs 6"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs7, GameObject.Find($"Clubs 7"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs8, GameObject.Find($"Clubs 8"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs9, GameObject.Find($"Clubs 9"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs10, GameObject.Find($"Clubs 10"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs11, GameObject.Find($"Clubs 11"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs12, GameObject.Find($"Clubs 12"));
        GameObjectStorage.Add(IdOfPlayingCards.Clubs13, GameObject.Find($"Clubs 13"));

        GameObjectStorage.Add(IdOfPlayingCards.Diamonds1, GameObject.Find($"Diamonds 1"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds2, GameObject.Find($"Diamonds 2"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds3, GameObject.Find($"Diamonds 3"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds4, GameObject.Find($"Diamonds 4"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds5, GameObject.Find($"Diamonds 5"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds6, GameObject.Find($"Diamonds 6"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds7, GameObject.Find($"Diamonds 7"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds8, GameObject.Find($"Diamonds 8"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds9, GameObject.Find($"Diamonds 9"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds10, GameObject.Find($"Diamonds 10"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds11, GameObject.Find($"Diamonds 11"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds12, GameObject.Find($"Diamonds 12"));
        GameObjectStorage.Add(IdOfPlayingCards.Diamonds13, GameObject.Find($"Diamonds 13"));

        GameObjectStorage.Add(IdOfPlayingCards.Hearts1, GameObject.Find($"Hearts 1"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts2, GameObject.Find($"Hearts 2"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts3, GameObject.Find($"Hearts 3"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts4, GameObject.Find($"Hearts 4"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts5, GameObject.Find($"Hearts 5"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts6, GameObject.Find($"Hearts 6"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts7, GameObject.Find($"Hearts 7"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts8, GameObject.Find($"Hearts 8"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts9, GameObject.Find($"Hearts 9"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts10, GameObject.Find($"Hearts 10"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts11, GameObject.Find($"Hearts 11"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts12, GameObject.Find($"Hearts 12"));
        GameObjectStorage.Add(IdOfPlayingCards.Hearts13, GameObject.Find($"Hearts 13"));

        GameObjectStorage.Add(IdOfPlayingCards.Spades1, GameObject.Find($"Spades 1"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades2, GameObject.Find($"Spades 2"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades3, GameObject.Find($"Spades 3"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades4, GameObject.Find($"Spades 4"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades5, GameObject.Find($"Spades 5"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades6, GameObject.Find($"Spades 6"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades7, GameObject.Find($"Spades 7"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades8, GameObject.Find($"Spades 8"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades9, GameObject.Find($"Spades 9"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades10, GameObject.Find($"Spades 10"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades11, GameObject.Find($"Spades 11"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades12, GameObject.Find($"Spades 12"));
        GameObjectStorage.Add(IdOfPlayingCards.Spades13, GameObject.Find($"Spades 13"));

        commandStorage = new ModelsOfTimeline.Model();
        gameModelBuffer = new GameModelBuffer();
        gameModel = new GameModel(gameModelBuffer);
        gameViewModel = new GameViewModel();

        // ゲーム開始時、とりあえず、すべてのカードは、いったん右の台札という扱いにする
        const int right = 0;// 台札の右
                            // const int left = 1;// 台札の左
        foreach (var idOfCard in GameObjectStorage.PlayingCards.Keys)
        {
            // 右の台札
            gameModelBuffer.IdOfCardsOfCenterStacks[right].Add(idOfCard);
        }

        // 右の台札をシャッフル
        gameModelBuffer.IdOfCardsOfCenterStacks[right] = gameModelBuffer.IdOfCardsOfCenterStacks[right].OrderBy(i => Guid.NewGuid()).ToList();

        // 右の台札をすべて、色分けして、黒色なら１プレイヤーの、赤色なら２プレイヤーの、手札に乗せる
        while (0 < gameModel.GetLengthOfCenterStackCards(right))
        {
            // 即実行
            new Commands.MoveCardsToPileFromCenterStacks(place: right).DoIt(gameModelBuffer, gameViewModel);
        }

        // １，２プレイヤーについて、手札から５枚抜いて、場札として置く（画面上の場札の位置は調整される）
        var time = 0.0f;
        this.commandStorage.Add(time, new Commands.MoveCardsToHandFromPile(player: 0, numberOfCards: 5));
        this.commandStorage.Add(time, new Commands.MoveCardsToHandFromPile(player: 1, numberOfCards: 5));

        // 以下、デモ・プレイを登録
        SetupDemo();

        // OnTick を 1.0 秒後に呼び出し、以降は unitSeconds 秒毎に実行
        InvokeRepeating(nameof(OnTick), 1.0f, unitSeconds);
    }

    // Update is called once per frame
    void Update()
    {
        // 入力をコマンドとして登録
        UpdateInput();
    }

    /// 
    /// 一定間隔で呼び出される
    /// 
    void OnTick()
    {
        // 時限式で、コマンドを消化
        this.commandStorage.DoIt(elapsedSeconds, gameModelBuffer, gameViewModel);

        elapsedSeconds += unitSeconds;
    }

    /// 
    /// 入力を、コマンドに変換して、タイムラインへ登録します
    /// 
    private void UpdateInput()
    {
        const int right = 0;// 台札の右
        const int left = 1;// 台札の左
        bool handled1player = false;
        bool handled2player = false;

        // 先に登録したコマンドの方が早く実行される

        // （ボタン押下が同時なら）右の台札は１プレイヤー優先
        // ==================================================

        if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: right // 右の
                ));
            handled1player = true;
        }

        if (Input.GetKeyDown(KeyCode.W))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: right // 右の
                ));
            handled2player = true;
        }

        // （ボタン押下が同時なら）左の台札は２プレイヤー優先
        // ==================================================

        // ２プレイヤー
        if (Input.GetKeyDown(KeyCode.S))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: left // 左の
                ));
            handled2player = true;
        }

        // １プレイヤー
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: left // 左の
                ));
            handled1player = true;
        }

        // それ以外のキー入力は、同時でも勝敗に関係しない
        // ==============================================

        // １プレイヤー
        if(handled1player)
        {

        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）左隣のカードをピックアップするように変えます
            var player = 0;
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveFocusToNextCard(
                player: player,
                direction: 1,
                setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                {
                    gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                }));
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）右隣のカードをピックアップするように変えます
            var player = 0;
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveFocusToNextCard(
                player: player,
                direction: 0,
                setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                {
                    gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                }));
        }

        // ２プレイヤー
        if(handled2player)
        {

        }
        else if (Input.GetKeyDown(KeyCode.A))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）左隣のカードをピックアップするように変えます
            var player = 1;
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveFocusToNextCard(
                player: player,
                direction: 1,
                setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                {
                    gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                }));
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）右隣のカードをピックアップするように変えます
            var player = 1;
            this.commandStorage.Add(elapsedSeconds, new Commands.MoveFocusToNextCard(
                player: player,
                direction: 0,
                setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                {
                    gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                }));
        }

        // デバッグ用
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 両プレイヤーは手札から１枚抜いて、場札として置く
            for (var player = 0; player < 2; player++)
            {
                // 場札を並べる
                this.commandStorage.Add(elapsedSeconds, new Commands.MoveCardsToHandFromPile(
                    player: player,
                    numberOfCards: 1));
            }
        }
    }

    /// 
    /// タイムライン作成
    /// 
    /// - デモ
    /// 
    void SetupDemo()
    {
        // 卓準備
        const int right = 0;// 台札の右
        const int left = 1;// 台札の左

        float scheduleSeconds = 1.0f;
        float oneSecond = 1.0f;

        // 登録：ピックアップ場札を、台札へ積み上げる
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、右の台札へ積み上げる
            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: right // 右の
                ));

            // ２プレイヤーが、ピックアップ中の場札を抜いて、左の台札へ積み上げる
            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: left // 左の
                ));

            scheduleSeconds += oneSecond;
        }

        // ゲーム・デモ開始

        // 登録：カード選択
        {
            for (int i = 0; i < 2; i++)
            {
                // １プレイヤーの右隣のカードへフォーカスを移します
                {
                    var player = 0;
                    this.commandStorage.Add(scheduleSeconds, new Commands.MoveFocusToNextCard(
                        player: player,
                        direction: 0,
                        setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                        {
                            gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                        }));
                }

                // ２プレイヤーの右隣のカードへフォーカスを移します
                {
                    var player = 1;
                    this.commandStorage.Add(scheduleSeconds, new Commands.MoveFocusToNextCard(
                        player: player,
                        direction: 0,
                        setIndexOfNextFocusedHandCard: (indexOfNextFocusedHandCard) =>
                        {
                            gameModelBuffer.IndexOfFocusedCardOfPlayers[player] = indexOfNextFocusedHandCard;     // 更新
                        }));
                }

                scheduleSeconds += oneSecond;
            }
        }

        // 登録：台札を積み上げる
        {
            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 0, // １プレイヤーが
                place: 1 // 左の台札
                ));

            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardToCenterStackFromHand(
                player: 1, // ２プレイヤーが
                place: 0 // 右の台札
                ));

            scheduleSeconds += oneSecond;
        }
        // 登録：手札から１枚引く
        {
            // １プレイヤーは手札から１枚抜いて、場札として置く
            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardsToHandFromPile(
                player: 0,
                numberOfCards: 1));

            // ２プレイヤーは手札から１枚抜いて、場札として置く
            this.commandStorage.Add(scheduleSeconds, new Commands.MoveCardsToHandFromPile(
                player: 1,
                numberOfCards: 1));

            scheduleSeconds += oneSecond;
        }
    }
}

「　👆　キー入力しても、コマンドは　ただちに実行せず、
いったん　タイムラインに登録するというのが、
ビューと　モデルを分離した工夫だぜ」

「　最初から　そうしろだぜ」

「　Unity の開発経験が　短いからね」

📅2023-02-01 sat 22:24

「　Lerp （リープ）を使うと、モーションを補間できるんじゃないの？」

「　やってみるかだぜ」

📄 Assets/Scripts/GameManager.cs file:

        /// 
        /// 場札を持ち上げる
        /// 
        /// 
        /// 
        internal void PickupCardOfHand(GameModel gameModel, int player, int handIndesx)
        {
            var idOfFocusedHandCard = gameModel.GetCardAtOfPlayerHand(player, handIndesx);

            var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
            var rotateY = -5; // -5°傾ける
            var rotateZ = -5; // -5°傾ける

            var goCard = GameObjectStorage.PlayingCards[idOfFocusedHandCard];
            goCard.transform.position = new Vector3(
                goCard.transform.position.x,
                goCard.transform.position.y + liftY,
                goCard.transform.position.z);
            goCard.transform.rotation = Quaternion.Euler(
                goCard.transform.rotation.eulerAngles.x,
                goCard.transform.rotation.eulerAngles.y + rotateY,
                goCard.transform.eulerAngles.z + rotateZ);
        }

「　👆　例えば、場札を持ち上げるのは、　position や rotation を上書きしていたが、
これをやめて、
持ち上げる前の position と rotation 、
持ち上げた後の position と rotation を持てばいいわけだぜ」

「　それを覚えておいて、 Update メソッドで Lerp() すればいいわけだぜ」

        /// 
        /// 場札を持ち上げる
        /// 
        /// 
        /// 
        internal void PickupCardOfHand(GameModel gameModel, int player, int handIndesx)
        {
            var idOfFocusedHandCard = gameModel.GetCardAtOfPlayerHand(player, handIndesx);

            var liftY = 5.0f; // 持ち上げる（パースペクティブがかかっていて、持ち上げすぎると北へ移動したように見える）
            var rotateY = -5; // -5°傾ける
            var rotateZ = -5; // -5°傾ける

            var goCard = GameObjectStorage.PlayingCards[idOfFocusedHandCard];

            var beginPosition = goCard.transform.position;
            var endPosition = new Vector3(
                goCard.transform.position.x,
                goCard.transform.position.y + liftY,
                goCard.transform.position.z);

            var beginRotation = goCard.transform.rotation;
            var endRotation = Quaternion.Euler(
                goCard.transform.rotation.eulerAngles.x,
                goCard.transform.rotation.eulerAngles.y + rotateY,
                goCard.transform.eulerAngles.z + rotateZ);

            // TODO ★ セットせず、 Lerp したい
            goCard.transform.position = endPosition;
            goCard.transform.rotation = endRotation;
        }

「　👆　この beginPosition、 endPosition、 beginRotation、 endRotation を
呼出し元へ　さかのぼって持っていけばいいのか、大変だな」

📺 開発中画面

「　👆　今日は　ここまでだぜ」

📅 2023-02-01 sat 23:58 end

📅2023-02-02 thu 18:44

📺 作業用BGM

「　👆　とりあえず、 Movement というクラスを作ろうぜ」

Assets/Scripts/Models/Timeline/Movement.cs file:

namespace Assets.Scripts.Models.Timeline
{
    using UnityEngine;

    /// 
    /// ゲーム・オブジェクトの動き
    /// 
    /// - Lerpに使うもの
    /// 
    internal class Movement
    {
        // - その他（生成）

        /// 
        /// 生成
        /// 
        /// 開始位置
        /// 終了位置
        /// 開始回転
        /// 終了回転
        /// ゲーム・オブジェクト
        public Movement(
            Vector3 beginPosition,
            Vector3 endPosition,
            Quaternion beginRotation,
            Quaternion endRotation,
            GameObject gameObject)
        {
            this.BeginPosition = beginPosition;
            this.EndPosition = endPosition;
            this.BeginRotation = beginRotation;
            this.EndRotation = endRotation;
            this.GameObject = gameObject;
        }

        // - プロパティ

        internal Vector3 BeginPosition { get; private set; }
        internal Vector3 EndPosition { get; private set; }
        internal Quaternion BeginRotation { get; private set; }
        internal Quaternion EndRotation { get; private set; }
        internal GameObject GameObject { get; private set; }
    }
}

「　👆　Lerp に使うデータを　持っておくクラスだな」

書き直す前のソース:

        /// 
        /// カードの位置と　捻りの設定
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// Update関数の中でないと役に立たない
        internal void SetPosRot(IdOfPlayingCards idOfCard, float x, float y, float z, float angleY = 180.0f, float angleZ = 0.0f, float motionProgress = 1.0f)
        {
            var goCard = GameObjectStorage.PlayingCards[idOfCard];
            var beginPos = goCard.transform.position;
            var endPos = new Vector3(x, y, z);

            goCard.transform.position = Vector3.Lerp(beginPos, endPos, motionProgress);
            goCard.transform.rotation = Quaternion.Euler(0, angleY, angleZ);
        }

書き直した後のソース:

        /// 
        /// カードの位置と　捻りの設定
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// Update関数の中でないと役に立たない
        internal void SetPosRot(IdOfPlayingCards idOfCard, float x, float y, float z, float angleY = 180.0f, float angleZ = 0.0f, float motionProgress = 1.0f)
        {
            var goCard = GameObjectStorage.PlayingCards[idOfCard];
            var movement = new Movement(
                beginPosition: goCard.transform.position,
                endPosition: new Vector3(x, y, z),
                beginRotation: goCard.transform.rotation,
                endRotation: Quaternion.Euler(0, angleY, angleZ),
                gameObject: goCard);

            goCard.transform.position = Vector3.Lerp(movement.BeginPosition, movement.EndPosition, motionProgress);
            goCard.transform.rotation = Quaternion.Lerp(movement.BeginRotation, movement.EndRotation, motionProgress);
        }

「　👆　動作が変わるんで　リファクタリング　ではなくて　仕様変更だが、
どんどん　Lerp　するコードを　関数の外側に出すための　仕込みをしていこう」

「　👆　SetPosRot という関数そのものが　よくないので、この関数は削除して
呼出し側に　ベタ書き　するように変えていこう」

「　最大２５枚の場札を　円弧上に　揃えて並べていく処理よ　それ」

「　じゃあ、タイムラインには　コマンドだけではなくて、
Movement　も置けた方がいいのか」

「　ICommand と、 Movement を、１本化しろだぜ」

Assets/Scripts/Models/Timeline/Commands/ICommand.cs file:

書き直す前のソース:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;

    /// 
    /// コマンド
    /// 
    interface ICommand
    {
        /// 
        /// コマンド実行
        /// 
        /// ゲームの内部状態（編集可能）
        /// 画面表示の状態（編集可能）
        void DoIt(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel);

        void Lerp(float progress);

        /// 
        /// 持続時間が切れたとき
        /// 
        void OnLeave();
    }
}

書き直した後のソース:

namespace Assets.Scripts.Models.Timeline.Commands
{
    using Assets.Scripts.Models;
    using Assets.Scripts.Views;

    /// 
    /// コマンド
    /// 
    interface ICommand
    {
        /// 
        /// 開始時
        /// 
        /// ゲームの内部状態（編集可能）
        /// 画面表示の状態（編集可能）
        void OnEnter(GameModelBuffer gameModelBuffer, GameViewModel gameViewModel);

        /// 
        /// 持続中
        /// 
        /// 進捗 0.0 ～ 1.0
        void Lerp(float progress);

        /// 
        /// 持続時間が切れたとき
        /// 
        void OnLeave();
    }
}

「　👆　DoIt を、 OnEnter に書き直すだけでも　一貫性が出てきそうだぜ」

「　コマンドに　開始時間と　持続時間　を持たせてしまえば　どうだぜ？
名前を　TimeSpan　にでも変えて、　コマンドはその特殊なケースにしろだぜ」

「　👆　TimedItem　と、　Command　と、　Movement　は、　TimeSpan　という枠組みで１本化したぜ」

📅 2023-02-01 sat 20:46 end

「　どんどん Lerp を使える形に変えていこう」

📅 2023-02-01 sat 21:02

「　👆　例えば　PutDownCardOfHand メソッドは、単に Movement インスタンスを作るだけのメソッドだと分かった」

「　頭の中が整理されてきたのね」

「　頭を整理してから　プログラミングしてくれだぜ」

        /// 
        /// 場札を並べる
        /// 
        /// - 左端は角度で言うと 112.0f
        /// 
        internal void ArrangeHandCards(GameModel gameModel, int player, LazyArgs.SetValue> setSpans)
        { // ...

「　👆　例えば　ArrangeHandCards メソッドは、単に Movement インスタンスを複数、作るだけのメソッドだと分かった」

📅 2023-02-01 sat 21:24

「　👆　あっ、バグった！」

「　表現しづらいバグを起こすなあ。
持ち上げるカードを　間違えているんだぜ　なぜか」

「　👆　タイム・スパンの　インスタンスの中で　即実行　するコードがあると　タイミングが狂ってる感じがするぜ」

「　OnEnter メソッドの中ではなく、 Lerp メソッドの中に書けば　いいんじゃない？」

        List SubSpans { get; set; }

        // - メソッド

        public override void Lerp(float progress)
        {
            base.Lerp(progress);

            if (this.SubSpans!=null)
            {
                foreach (var span in this.SubSpans)
                {
                    span.Lerp(progress);
                }
            }
        }

「　👆　なるほど」

「　👆　ダメだぜ。持ち上げるカードを間違えているぜ」

「　コマンドのタイム・スパンの寿命と、
場札の位置調整をしたいタイム・スパンの寿命は　別物だからでは？」

「　じゃあ　タイム・スパンを新しく　スポーン（Spawn；生成）しなくちゃ　いけないのよ」

「　👆　タイムライン・モデルは　ゲーム・モデルの外側にあるし、　ゲーム・ビュー・モデルの外側でもあるぜ。
タイムライン・モデルは　モデル　なのだろうか？　ビュー　なのだろうか？」

「　画面に表示されてないから、モデルだろ」

「　モデルのくせに、ゲーム・オブジェクトを持ってるのは　良くない」

「　タイムライン・モデルの　モデルとビューの分離　を先に行っておくべきだったんじゃない？」

「　👆　今なら　Discard（ディスカード；更新の破棄）しても　ダメージは３０分レベルで軽微だから　ロールバック（Rollback；巻き戻し）するかだぜ」

📅 2023-02-01 sat 21:49

「　巻き戻した」

「　👆　モデルが　ビューを持ってると　良くないんだぜ」

「　👆　じゃあ　Lerp メソッドのような、ビュー　に属するものを　タイムライン・モデルが　持っていては
いけなくないかだぜ？」

「　そりゃそうだぜ」

「　TimelineView のようなものが　要るのかしら？」

📅 2023-02-02 sat 22:20

「　👆　OnEnter メソッドは　モデルを扱い、
Lerp メソッドは　ビューを扱うというように　ぱっきり　分かれているので、
TimeSpan も　モデルとビューに分けられないかだぜ？」

「　あっ、トランプの絵柄を取得できるメソッドが欲しいぜ」

Assets/Scripts/Models/IdOfCardSuits.cs file:

namespace Assets.Scripts.Models
{
    /// 
    /// カードのスート（絵柄）
    /// 
    internal enum IdOfCardSuits
    {
        None,

        Clubs,

        Diamonds,

        Hearts,

        Spades,
    }
}

Assets/Scripts/Models/IdOfCardSuits.cs file:

namespace Assets.Scripts.Models
{
    using System;

    /// 
    /// トランプのカード
    /// 
    /// - ジョーカーを除く
    /// 
    internal enum IdOfPlayingCards
    {
        // ... 中略 ...
    }

    static class IdOfPlayingCardsExtensions
    {
        public static IdOfCardSuits Suit(this IdOfPlayingCards idOfCard)
        {
            switch (idOfCard)
            {
                case IdOfPlayingCards.Clubs1: 
                case IdOfPlayingCards.Clubs2: 
                case IdOfPlayingCards.Clubs3: 
                case IdOfPlayingCards.Clubs4: 
                case IdOfPlayingCards.Clubs5: 
                case IdOfPlayingCards.Clubs6: 
                case IdOfPlayingCards.Clubs7: 
                case IdOfPlayingCards.Clubs8: 
                case IdOfPlayingCards.Clubs9: 
                case IdOfPlayingCards.Clubs10: 
                case IdOfPlayingCards.Clubs11: 
                case IdOfPlayingCards.Clubs12: 
                case IdOfPlayingCards.Clubs13:
                    return IdOfCardSuits.Clubs;

                case IdOfPlayingCards.Diamonds1:
                case IdOfPlayingCards.Diamonds2:
                case IdOfPlayingCards.Diamonds3:
                case IdOfPlayingCards.Diamonds4:
                case IdOfPlayingCards.Diamonds5:
                case IdOfPlayingCards.Diamonds6:
                case IdOfPlayingCards.Diamonds7:
                case IdOfPlayingCards.Diamonds8:
                case IdOfPlayingCards.Diamonds9:
                case IdOfPlayingCards.Diamonds10:
                case IdOfPlayingCards.Diamonds11:
                case IdOfPlayingCards.Diamonds12:
                case IdOfPlayingCards.Diamonds13:
                    return IdOfCardSuits.Diamonds;

                case IdOfPlayingCards.Hearts1:
                case IdOfPlayingCards.Hearts2:
                case IdOfPlayingCards.Hearts3:
                case IdOfPlayingCards.Hearts4:
                case IdOfPlayingCards.Hearts5:
                case IdOfPlayingCards.Hearts6:
                case IdOfPlayingCards.Hearts7:
                case IdOfPlayingCards.Hearts8:
                case IdOfPlayingCards.Hearts9:
                case IdOfPlayingCards.Hearts10:
                case IdOfPlayingCards.Hearts11:
                case IdOfPlayingCards.Hearts12:
                case IdOfPlayingCards.Hearts13:
                    return IdOfCardSuits.Hearts;

                case IdOfPlayingCards.Spades1:
                case IdOfPlayingCards.Spades2:
                case IdOfPlayingCards.Spades3:
                case IdOfPlayingCards.Spades4:
                case IdOfPlayingCards.Spades5:
                case IdOfPlayingCards.Spades6:
                case IdOfPlayingCards.Spades7:
                case IdOfPlayingCards.Spades8:
                case IdOfPlayingCards.Spades9:
                case IdOfPlayingCards.Spades10:
                case IdOfPlayingCards.Spades11:
                case IdOfPlayingCards.Spades12:
                case IdOfPlayingCards.Spades13:
                    return IdOfCardSuits.Spades;

                default: throw new ArgumentOutOfRangeException("idOfCard");
            }
        }
    }
}

📅 2023-02-03 sat 00:12

「　👆　作った」

📅 2023-02-03 sat 02:00

「　👆　タイム・ライン登録時は　まだ　座標が動いてないから、
タイム・ライン登録中も　座標を動かしてやらないと　いけないぜ。
この不具合は　また今度直そう」

📺 開発中画面

「　今日は　ここまで」

📅2023-02-03 fri 18:48

「　しばらく　作り直し」

📅 2023-02-04 sat 02:07

「　👆　７時間ぐらいバグ探して　１つ　直した。
操作を２連続で行うと　カードが変なところに飛んでいくので、
２つの操作を結合して、１回の操作にする」

📺 開発中画面

「　今日はここまで」

📅2023-02-04 sat 12:02

「　作ってみると　分からないところが　いっぱい出てくる。散々だぜ」

📅 2023-02-04 sat 13:53

「　👆　GameViewModel を廃止し、静的クラスにしたぜ」

📅 2023-02-04 sat 19:43

「　👆　怪しい場所を発見したぜ」

「　修正したが、バグが直る様子なし」

📅 2023-02-04 sat 21:20

「　👆　5.0 だけ持ち上げたいのに、すでに 25.5　も持ち上がってたら、　６倍ぐらい　飛び上がるよな」

「　1.06、 2.17、 3.83、 6.06、 8.83、 12.17、 16.06、 20.50、 25.50 は、
+1.06、 +1.11、 +1.66、 +2.23、 +2.77、 +3.34、 +3.89、 +4.44、 +5.0 だぜ」

「　加速していく 5.0 を累計してんの？」

「　なんで勝手に　積分してんだぜ？　調べるか……」

「　👆　説明するのは難しいが　理解した。
開始地点から　終了地点まで　刻んで動け、という命令をしてるときに
開始地点が　刻々と　進んでいるんだぜ」

「　開始地点は　動くなだぜ」

「　👆　こういう書き方で　修正できたが、
こんな書き方が役に立つ場面　初めて見た。
不思議な気分だぜ」

📺 開発中画面

📅 2023-02-04 sat 23:55

「　👆　思ったのと　違う動きをしているが、
不具合のリクツが分かってきたのは前進だぜ」

「　今日は　ここまでだぜ」

📅2023-02-05 sun 12:27

「　バグ探ししてるだけで　進展なし」

📅 2023-02-05 sat 17:53

「　👆　１か所　変更して　様子を見るぜ」

📺 開発中画面

📅 2023-02-05 sat 18:02

「　👆　カードが飛び上がるのは　なくなったぜ」

「　連打を禁止したら　どうだぜ？
Lerp が重なってるケースがあるのでは？」

📅 2023-02-05 sat 18:09

「　👆　入力系は　こんがらがると　大変だろうから　ゲーム・マネージャーと分離するぜ」

「　疲れた　ラーメン食べに行く　いったん休憩！」

「　おつ」

📅 2023-02-05 sat 18:10 end

📅2023-02-06 sun 02:06

「　３時間寝たと思ったら目が覚めた。練習しよ」

📅 2023-02-06 mon 03:28

「　👆　やることの順番を　少しでも　前後間違えると　違った動きをする。
直した」

📺 開発中画面

「　👆　やったな！」

📺 開発中画面

📅 2023-02-06 mon 04:13

「　👆　今朝は　ここまで」

「　おつ」

📅2023-02-07 tue 03:59

「　睡眠が　長続きせず　途切れてしまった。　練習するか」

📅 2023-02-06 mon 05:03

Assets/Scripts/Gui/GameManager.cs file:

    // - プロパティ

    // モデル・バッファー
    GameModelBuffer modelBuffer = new GameModelBuffer();

    /// 
    /// ゲーム・モデル
    /// 
    internal GameModel Model
    {
        get
        {
            if (model == null)
            {
                // ゲーム・モデルは、ゲーム・モデル・バッファーを持つ
                model = new GameModel(modelBuffer);
            }
            return model;
        }
    }
    GameModel model;


    /// 
    /// スケジュール・レジスター
    /// 
    internal ScheduleRegister ScheduleRegister
    {
        get
        {
            if (scheduleRegister == null)
            {
                // スケジューラー・レジスターは、ゲーム・モデルを持つ。
                scheduleRegister = new TimedGeneratorOfSpanOfLearp.ScheduleRegister(this.Model);
            }
            return scheduleRegister;
        }
    }
    ScheduleRegister scheduleRegister;

「　👆　プロパティは、ゲットしたタイミングで生成されるようにするぜ。
どのゲーム・オブジェクトの Start() イベントハンドラから実行されるか　順番が不定なケースではこうする」

Assets/Scripts/Gui/InputManager.cs file:

using Assets.Scripts.Gui.SpanOfLerp.TimedGenerator;
using Assets.Scripts.ThinkingEngine.CommandArgs;
using UnityEngine;

public class InputManager : MonoBehaviour
{
    // - フィールド

    ScheduleRegister scheduleRegister;

    // - イベントハンドラ

    // Start is called before the first frame update
    void Start()
    {
        scheduleRegister = GameObject.Find("Game Manager").GetComponent().ScheduleRegister;
    }

    /// 
    /// Update is called once per frame
    /// 
    /// - 入力は、すぐに実行は、しません
    /// - 入力は、コマンドに変換して、タイムラインへ登録します
    /// 
    void Update()
    {
        const int right = 0;// 台札の右
        const int left = 1;// 台札の左
        bool handled1player = false;
        bool handled2player = false;

        // 先に登録したコマンドの方が早く実行される

        // （ボタン押下が同時なら）右の台札は１プレイヤー優先
        // ==================================================

        if (Input.GetKeyDown(KeyCode.DownArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            scheduleRegister.AddJustNow(new MoveCardToCenterStackFromHandModel(
                player: 0,      // １プレイヤーが
                place: right)); // 右の
            handled1player = true;
        }

        if (Input.GetKeyDown(KeyCode.W))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            scheduleRegister.AddJustNow(new MoveCardToCenterStackFromHandModel(
                player: 1, // ２プレイヤーが
                place: right)); // 右の
            handled2player = true;
        }

        // （ボタン押下が同時なら）左の台札は２プレイヤー優先
        // ==================================================

        // ２プレイヤー
        if (Input.GetKeyDown(KeyCode.S))
        {
            // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            scheduleRegister.AddJustNow(new MoveCardToCenterStackFromHandModel(
                player: 1,      // ２プレイヤーが
                place: left));  // 左の
            handled2player = true;
        }

        // １プレイヤー
        if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
            scheduleRegister.AddJustNow(new MoveCardToCenterStackFromHandModel(
                player: 0, // １プレイヤーが
                place: left));  // 左の
            handled1player = true;
        }

        // それ以外のキー入力は、同時でも勝敗に関係しない
        // ==============================================

        // １プレイヤー
        if (handled1player)
        {

        }
        else if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）左隣のカードをピックアップするように変えます
            scheduleRegister.AddJustNow(new MoveFocusToNextCardModel(
                player: 0,
                direction: 1));
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）右隣のカードをピックアップするように変えます
            scheduleRegister.AddJustNow(new MoveFocusToNextCardModel(
                player: 0,
                direction: 0));
        }

        // ２プレイヤー
        if (handled2player)
        {

        }
        else if (Input.GetKeyDown(KeyCode.A))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）左隣のカードをピックアップするように変えます
            scheduleRegister.AddJustNow(new MoveFocusToNextCardModel(
                player: 1,
                direction: 1));
        }
        else if (Input.GetKeyDown(KeyCode.D))
        {
            // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）右隣のカードをピックアップするように変えます
            scheduleRegister.AddJustNow(new MoveFocusToNextCardModel(
                player: 1,
                direction: 0));
        }

        // デバッグ用
        if (Input.GetKeyDown(KeyCode.Space))
        {
            // 両プレイヤーは手札から１枚抜いて、場札として置く
            for (var player = 0; player < 2; player++)
            {
                // 場札を並べる
                scheduleRegister.AddJustNow(new MoveCardsToHandFromPileModel(
                    player: player,
                    numberOfCards: 1));
            }
        }
    }
}

📅 2023-02-07 tue 05:03

「　👆　入力は、入力されたらすぐ実行するということはせず、
入力時のゲーム時間を付けて、スケジュール・レジスターに　コマンドを登録するぜ」

📅 2023-02-07 tue 05:04

「　👆　入力の中に、ゲームの制約を書き込むと　読みづらくなるので、
LegalManager というのを別途作って、こっちに　ゲームの制約を組み込んでいくぜ」

Assets/Scripts/ThinkingEngine/IdOfPlayingCards.cs file:

namespace Assets.Scripts.ThinkingEngine
{
    using System;

    /// 
    /// トランプのカード
    /// 
    /// - ジョーカーを除く
    /// 
    internal enum IdOfPlayingCards
    { // ...
    }

    static class IdOfPlayingCardsExtensions
    {
        public static IdOfCardSuits Suit(this IdOfPlayingCards idOfCard)
        { // ...
        }

        public static int Number(this IdOfPlayingCards idOfCard)
        {
            switch (idOfCard)
            {
                case IdOfPlayingCards.Clubs1:
                case IdOfPlayingCards.Diamonds1:
                case IdOfPlayingCards.Hearts1:
                case IdOfPlayingCards.Spades1:
                    return 1;

                case IdOfPlayingCards.Clubs2:
                case IdOfPlayingCards.Diamonds2:
                case IdOfPlayingCards.Hearts2:
                case IdOfPlayingCards.Spades2:
                    return 2;

                case IdOfPlayingCards.Clubs3:
                case IdOfPlayingCards.Diamonds3:
                case IdOfPlayingCards.Hearts3:
                case IdOfPlayingCards.Spades3:
                    return 3;

                case IdOfPlayingCards.Clubs4:
                case IdOfPlayingCards.Diamonds4:
                case IdOfPlayingCards.Hearts4:
                case IdOfPlayingCards.Spades4:
                    return 4;

                case IdOfPlayingCards.Clubs5:
                case IdOfPlayingCards.Diamonds5:
                case IdOfPlayingCards.Hearts5:
                case IdOfPlayingCards.Spades5:
                    return 5;

                case IdOfPlayingCards.Clubs6:
                case IdOfPlayingCards.Diamonds6:
                case IdOfPlayingCards.Hearts6:
                case IdOfPlayingCards.Spades6:
                    return 6;

                case IdOfPlayingCards.Clubs7:
                case IdOfPlayingCards.Diamonds7:
                case IdOfPlayingCards.Hearts7:
                case IdOfPlayingCards.Spades7:
                    return 7;

                case IdOfPlayingCards.Clubs8:
                case IdOfPlayingCards.Diamonds8:
                case IdOfPlayingCards.Hearts8:
                case IdOfPlayingCards.Spades8:
                    return 8;

                case IdOfPlayingCards.Clubs9:
                case IdOfPlayingCards.Diamonds9:
                case IdOfPlayingCards.Hearts9:
                case IdOfPlayingCards.Spades9:
                    return 9;

                case IdOfPlayingCards.Clubs10:
                case IdOfPlayingCards.Diamonds10:
                case IdOfPlayingCards.Hearts10:
                case IdOfPlayingCards.Spades10:
                    return 10;

                case IdOfPlayingCards.Clubs11:
                case IdOfPlayingCards.Diamonds11:
                case IdOfPlayingCards.Hearts11:
                case IdOfPlayingCards.Spades11:
                    return 11;

                case IdOfPlayingCards.Clubs12:
                case IdOfPlayingCards.Diamonds12:
                case IdOfPlayingCards.Hearts12:
                case IdOfPlayingCards.Spades12:
                    return 12;

                case IdOfPlayingCards.Clubs13:
                case IdOfPlayingCards.Diamonds13:
                case IdOfPlayingCards.Hearts13:
                case IdOfPlayingCards.Spades13:
                    return 13;

                default: throw new ArgumentOutOfRangeException("idOfCard");
            }
        }
    }
}

📅 2023-02-07 tue 05:24

「　👆　トランプ・カードのIdを、数に変える方法が無かったので、作っておくぜ」

Assets/Scripts/ThinkingEngine/LegalMove.cs file:

namespace Assets.Scripts.ThinkingEngine
{
    internal class LegalMove
    {
        // - メソッド

        internal static bool CanPutToCenterStack(GameModel gameModel, int player, int place)
        {
            int index = gameModel.GetIndexOfFocusedCardOfPlayer(player);
            if (index == -1)
            {
                return false;
            }

            IdOfPlayingCards topCard = gameModel.GetLastCardOfCenterStack(place);
            if (topCard == IdOfPlayingCards.None)
            {
                return false;
            }

            var numberOfPickup = gameModel.GetCardsOfPlayerHand(player)[index].Number();
            int numberOfTopCard = topCard.Number();

            // とりあえず差分を取る。
            // 負数が出ると、負数の剰余はプログラムによって結果が異なるので、面倒だ。
            // 割る数を先に足しておけば、剰余をしても負数にはならない
            int divisor = 13; // 法
            int remainder = (numberOfTopCard - numberOfPickup + divisor) % divisor;

            return remainder == 1 || remainder == divisor - 1;
        }
    }
}

📅 2023-02-07 tue 06:10

「　👆　LegalManager というゲーム・オブジェクトにアタッチする C#スクリプトは止めて、
LegalMove という静的クラスを作ったぜ」

        // （ボタン押下が同時なら）右の台札は１プレイヤー優先
        // ==================================================

        if (Input.GetKeyDown(KeyCode.DownArrow) && LegalMove.CanPutToCenterStack(
            gameModel: scheduleRegister.GameModel,
            player: 0,      // １プレイヤーが
            place: right))  // 右の
        {
            // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
            scheduleRegister.AddJustNow(new MoveCardToCenterStackFromHandModel(
                player: 0,      // １プレイヤーが
                place: right)); // 右の
            handled1player = true;
        }

「　👆　こんな風に、入力に制約を付ける感じで使う」

「　ついでに、ボタン連打をするという　スパム行為　をやめさせたいな。
前に押してから　何秒経過するまで　次の入力ができないというような　制約を付ければいいのかだぜ？」

📺 作業用BGM

📅 2023-02-07 tue 07:03

「　👆　コマンドには　持続時間が自動的にセットされるようにして……」

「　すべての入力は　コマンドに変換してから実行されるという　建付け　にしておけば、
入力による　必要な待機時間は　決まるな」

    // - フィールド
    // ...

    float[] spamSeconds = new[] { 0f, 0f };

    // - イベントハンドラ
    // ...

    void Update()
    {
        // もう入力できないなら真
        bool[] handled = { false, false };

        for (var player = 0; player < 2; player++)
        {
            // 前判定
            // もう入力できないなら真
            handled[player] = 0 < spamSeconds[player];

            // スパン時間消化
            if (0 < spamSeconds[player])
            {
                // 負数になっても気にしない
                spamSeconds[player] -= Time.deltaTime;
            }
        }

        const int right = 0;// 台札の右
        const int left = 1;// 台札の左

        // 先に登録したコマンドの方が早く実行される

        // （ボタン押下が同時なら）右の台札は１プレイヤー優先
        // ==================================================

        // １プレイヤー
        {
            var player = 0;
            if (!handled[player] && Input.GetKeyDown(KeyCode.DownArrow) && LegalMove.CanPutToCenterStack(
                gameModel: scheduleRegister.GameModel,
                player: player,
                place: right))  // 右の
            {
                // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardToCenterStackFromHandModel(
                    player: player,      // １プレイヤーが
                    place: right)); // 右の

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
                handled[player] = true;
            }
        }

// ...

📅 2023-02-07 tue 08:15

「　👆　キー入力したら、コマンドに対応づく持続時間を覚えておいて、
その時間を消化しきるまで　次の入力ができないようにするぜ」

「　今朝は　ここまで」

📅2023-02-09 thu 18:26

「　動作テストを勝手にしてくれるＡＩを入れたいぜ」

「　右、上、下、スペース　を押してくれるだけで　いいんじゃない？」

「　じゃあ　ひとまず、
１P vs ２P、
１P vs COM、
COM vs ２P、
COM vs COM
のボタンを作るかだぜ？」

📅 2023-02-09 thu 18:54

「　👆　Shader を UI/Default にすると半透明にできるの、ノーヒントでは　気づかないよな」

📅 2023-02-09 thu 18:57

「　👆　UIManager を作るぜ」

「　大改造」

📅 2023-02-09 thu 22:48

Assets/Scripts/Gui/InputManager/ToMeaning.cs file:

namespace Assets.Scripts.Gui.InputManager
{
    using UnityEngine;

    /// 
    /// キー入力の解析
    /// 
    internal class ToMeaning
    {
        // - プロパティ

        /// 
        /// 自分に近い方の台札へ置く
        /// 
        internal bool[] MoveCardToCenterStackNearMe { get; private set; } = new[] { false, false };

        /// 
        /// 自分から遠い方の台札へ置く
        /// 
        internal bool[] MoveCardToFarCenterStack { get; private set; } = new[] { false, false };

        /// 
        /// 自分から見て（今ピックアップしているカードの）右隣のカードをピックアップ
        /// 
        internal bool[] PickupCardToForward { get; private set; } = new[] { false, false };

        /// 
        /// 自分から見て（今ピックアップしているカードの）左隣のカードをピックアップ
        /// 
        internal bool[] PickupCardToBackward { get; private set; } = new[] { false, false };

        /// 
        /// 手札から場札を補充する
        /// 
        internal bool Drawing { get; private set; } = false;

        // - メソッド

        /// 
        /// 解析結果を全部消す
        /// 
        internal void Clear()
        {
            for (var player = 0; player < 2; player++)
            {
                MoveCardToCenterStackNearMe[player] = false;
                MoveCardToFarCenterStack[player] = false;
                PickupCardToForward[player] = false;
                PickupCardToBackward[player] = false;
            }

            Drawing = false;
        }

        /// 
        /// 物理的なキー入力を、意味的に置き換える
        /// 
        /// 
        internal void UpdateFromInput(int player)
        {
            if (player == 0)
            {
                MoveCardToCenterStackNearMe[player] = Input.GetKeyDown(KeyCode.DownArrow);
                MoveCardToFarCenterStack[player] = Input.GetKeyDown(KeyCode.UpArrow);
                PickupCardToForward[player] = Input.GetKeyDown(KeyCode.RightArrow);
                PickupCardToBackward[player] = Input.GetKeyDown(KeyCode.LeftArrow);
            }
            else
            {
                MoveCardToCenterStackNearMe[player] = Input.GetKeyDown(KeyCode.S);
                MoveCardToFarCenterStack[player] = Input.GetKeyDown(KeyCode.W);
                PickupCardToForward[player] = Input.GetKeyDown(KeyCode.D);
                PickupCardToBackward[player] = Input.GetKeyDown(KeyCode.A);
            }

            Drawing = Input.GetKeyDown(KeyCode.Space); // １プレイヤーと、２プレイヤーの２回判定されてしまう
        }

        /// 
        /// 解析結果を全部上書きする
        /// 
        internal void Overwrite(
            int player,
            bool moveCardToCenterStackNearMe,
            bool moveCardToFarCenterStack,
            bool pickupCardToForward,
            bool pickupCardToBackward,
            bool drawing)
        {
            MoveCardToCenterStackNearMe[player] = moveCardToCenterStackNearMe;
            MoveCardToFarCenterStack[player] = moveCardToFarCenterStack;
            PickupCardToForward[player] = pickupCardToForward;
            PickupCardToBackward[player] = pickupCardToBackward;
            Drawing = drawing;
        }
    }
}

「　👆　何キーを押したかではなく、どういう意図で押したかで　データを持つクラスを作るぜ」

📅 2023-02-09 thu 22:51

Assets/Scripts/ThinkingEngine/Computer.cs file:

namespace Assets.Scripts.ThinkingEngine
{
    using Assets.Scripts.ThinkingEngine.Model;

    /// 
    /// コンピューター・プレイヤー
    /// 
    internal class Computer
    {
        // - その他

        internal Computer(int number)
        {
            this.Number = number;
        }

        // - プロパティ

        /// 
        /// プレイヤー番号
        /// 
        /// - 1プレイヤーなら0
        /// 
        public int Number { get; private set; }

        /// 
        /// 自分に近い方の台札へ置く
        /// 
        internal bool MoveCardToCenterStackNearMe { get; private set; }

        /// 
        /// 自分から遠い方の台札へ置く
        /// 
        internal bool MoveCardToFarCenterStack { get; private set; }

        /// 
        /// 自分から見て（今ピックアップしているカードの）右隣のカードをピックアップ
        /// 
        internal bool PickupCardToForward { get; private set; }

        /// 
        /// 自分から見て（今ピックアップしているカードの）左隣のカードをピックアップ
        /// 
        internal bool PickupCardToBackward { get; private set; }

        /// 
        /// 手札から場札を補充する
        /// 
        internal bool Drawing { get; private set; }

        // - メソッド

        /// 
        /// コンピューター・プレイヤーが思考して、操作を決める
        /// 
        /// 現在の局面
        internal void Think(GameModel gameModel)
        {
            // 今回の入力予定
            var moveCardToCenterStackNearMe = false;
            var moveCardToFarCenterStack = false;
            var pickupCardToForward = false;
            var pickupCardToBackward = false;
            var drawing = false;

            // 順繰りにやってるだけ
            if (this.MoveCardToCenterStackNearMe == false && this.MoveCardToFarCenterStack == false && this.PickupCardToForward == false && this.Drawing == false)
            {
                moveCardToCenterStackNearMe = true;
            }
            else if (this.MoveCardToCenterStackNearMe)
            {
                moveCardToCenterStackNearMe = false;
                moveCardToFarCenterStack = true;
            }
            else if (this.MoveCardToFarCenterStack)
            {
                moveCardToFarCenterStack = false;
                pickupCardToForward = true;
            }
            else if (this.PickupCardToForward)
            {
                pickupCardToForward = false;
                drawing = true;
            }
            else if (this.Drawing)
            {
                drawing = false;
                moveCardToCenterStackNearMe = true;
            }

            // 今回の入力
            this.MoveCardToCenterStackNearMe = moveCardToCenterStackNearMe;
            this.MoveCardToFarCenterStack = moveCardToFarCenterStack;
            this.PickupCardToForward = pickupCardToForward;
            this.PickupCardToBackward = pickupCardToBackward;
            this.Drawing = drawing;
        }
    }
}

「　👆　コンピューターは　順繰りに　キーを押してるだけ」

📅 2023-02-09 thu 22:54

Assets/Scripts/Gui/InputManager.cs file:

using GuiOfInputManager = Assets.Scripts.Gui.InputManager;
using Assets.Scripts.Gui.SpanOfLerp.TimedGenerator;
using Assets.Scripts.ThinkingEngine.Model;
using Assets.Scripts.ThinkingEngine.Model.CommandArgs;
using UnityEngine;
using GuiOfTimedCommandArgs = Assets.Scripts.Gui.TimedCommandArgs;
using Assets.Scripts.ThinkingEngine;

public class InputManager : MonoBehaviour
{
    // - フィールド

    ScheduleRegister scheduleRegister;

    /// 
    /// コンピューター・プレイヤー用
    /// 
    GameModel gameModel;

    float[] spamSeconds = new[] { 0f, 0f };

    /// 
    /// コンピューター・プレイヤーか？
    /// 
    /// - コンピューターなら Computer インスタンス
    /// - コンピューターでなければヌル
    /// 
    internal Computer[] Computers { get; set; } = new Computer[] { new Computer(0), new Computer(1), };

    GuiOfInputManager.ToMeaning inputToMeaning = new GuiOfInputManager.ToMeaning();

    // - イベントハンドラ

    // Start is called before the first frame update
    void Start()
    {
        var gameManager = GameObject.Find("Game Manager").GetComponent();
        scheduleRegister = gameManager.ScheduleRegister;
        gameModel = gameManager.Model;
    }

    /// 
    /// Update is called once per frame
    /// 
    /// - 入力は、すぐに実行は、しません
    /// - 入力は、コマンドに変換して、タイムラインへ登録します
    /// 
    void Update()
    {
        // キー入力の解析：クリアー
        inputToMeaning.Clear();

        // もう入力できないなら真
        bool[] handled = { false, false };

        for (var player = 0; player < 2; player++)
        {
            // 前判定：もう入力できないなら真
            //
            // - スパム中
            // - 対局停止中
            handled[player] = 0 < spamSeconds[player] || !gameModel.IsGameActive;

            if (!handled[player])
            {
                if (Computers[player] == null)
                {
                    // キー入力の解析：人間の入力を受付
                    inputToMeaning.UpdateFromInput(player);
                }
                else
                {
                    // コンピューター・プレイヤーが思考して、操作を決める
                    Computers[player].Think(gameModel);

                    // キー入力の解析：コンピューターからの入力を受付
                    inputToMeaning.Overwrite(
                        player: player,
                        moveCardToCenterStackNearMe: Computers[player].MoveCardToCenterStackNearMe,
                        moveCardToFarCenterStack: Computers[player].MoveCardToFarCenterStack,
                        pickupCardToForward: Computers[player].PickupCardToForward,
                        pickupCardToBackward: Computers[player].PickupCardToBackward,
                        drawing: Computers[player].Drawing);
                }
            }

            // スパン時間消化
            if (0 < spamSeconds[player])
            {
                // 負数になっても気にしない
                spamSeconds[player] -= Time.deltaTime;
            }
        }

        const int right = 0;// 台札の右
        const int left = 1;// 台札の左

        // 先に登録したコマンドの方が早く実行される

        // （ボタン押下が同時なら）右の台札は１プレイヤー優先
        // ==================================================

        // １プレイヤー
        {
            var player = 0;
            if (!handled[player] && inputToMeaning.MoveCardToCenterStackNearMe[player] && LegalMove.CanPutToCenterStack(
                gameModel: scheduleRegister.GameModel,
                player: player,
                place: right))  // 右の
            {
                // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardToCenterStackFromHandModel(
                    player: player,      // １プレイヤーが
                    place: right)); // 右の

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
                handled[player] = true;
            }
        }

        // ２プレイヤー
        {
            var player = 1;
            if (!handled[player] && inputToMeaning.MoveCardToFarCenterStack[player] && LegalMove.CanPutToCenterStack(
                gameModel: scheduleRegister.GameModel,
                player: player,
                place: right))  // 右の)
            {
                // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）右の台札へ積み上げる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardToCenterStackFromHandModel(
                    player: player,      // ２プレイヤーが
                    place: right)); // 右の

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
                handled[player] = true;
            }
        }

        // （ボタン押下が同時なら）左の台札は２プレイヤー優先
        // ==================================================

        // ２プレイヤー
        {
            var player = 1;
            if (!handled[player] && inputToMeaning.MoveCardToCenterStackNearMe[player] && LegalMove.CanPutToCenterStack(
                gameModel: scheduleRegister.GameModel,
                player: player,
                place: left))
            {
                // ２プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardToCenterStackFromHandModel(
                    player: player,      // ２プレイヤーが
                    place: left));  // 左の

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
                handled[player] = true;
            }
        }

        // １プレイヤー
        {
            var player = 0;
            if (!handled[player] && inputToMeaning.MoveCardToFarCenterStack[player] && LegalMove.CanPutToCenterStack(
                gameModel: scheduleRegister.GameModel,
                player: player,
                place: left))
            {
                // １プレイヤーが、ピックアップ中の場札を抜いて、（１プレイヤーから見て）左の台札へ積み上げる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardToCenterStackFromHandModel(
                    player: player,      // １プレイヤーが
                    place: left));  // 左の

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
                handled[player] = true;
            }
        }

        // それ以外のキー入力は、同時でも勝敗に関係しない
        // ==============================================

        // １プレイヤー
        {
            var player = 0;

            if (handled[player])
            {

            }
            else if (inputToMeaning.PickupCardToBackward[player])
            {
                // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）左隣のカードをピックアップするように変えます
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveFocusToNextCardModel(
                    player: player,
                    direction: 1));

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
            }
            else if (inputToMeaning.PickupCardToForward[player])
            {
                // １プレイヤーのピックアップしているカードから見て、（１プレイヤーから見て）右隣のカードをピックアップするように変えます
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveFocusToNextCardModel(
                    player: player,
                    direction: 0));

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
            }
        }

        // ２プレイヤー
        {
            var player = 1;

            if (handled[player])
            {

            }
            else if (inputToMeaning.PickupCardToBackward[player])
            {
                // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）左隣のカードをピックアップするように変えます
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveFocusToNextCardModel(
                    player: player,
                    direction: 1));

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
            }
            else if (inputToMeaning.PickupCardToForward[player])
            {
                // ２プレイヤーのピックアップしているカードから見て、（２プレイヤーから見て）右隣のカードをピックアップするように変えます
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveFocusToNextCardModel(
                    player: player,
                    direction: 0));

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
            }
        }

        // デバッグ用
        if (inputToMeaning.Drawing)
        {
            // 両プレイヤーは手札から１枚抜いて、場札として置く
            for (var player = 0; player < 2; player++)
            {
                // 場札を並べる
                var timedCommandArg = new GuiOfTimedCommandArgs.Model(new MoveCardsToHandFromPileModel(
                    player: player,
                    numberOfCards: 1));

                spamSeconds[player] = timedCommandArg.Duration;
                scheduleRegister.AddJustNow(timedCommandArg);
            }
        }
    }
}

「　👆　人間のキー入力も、コンピューターのキー入力も、
同じルーチンに合流するように　しておくぜ」

📅 2023-02-09 thu 22:59

Assets/Scripts/Gui/GameManager.cs file:

// ... 前略 ...

        // 登録：ピックアップ場札を、台札へ積み上げる
        {
            {
                // １プレイヤーが、ピックアップ中の場札を抜いて、右の台札へ積み上げる
                var player = 0;
                var spanModel = new MoveCardToCenterStackFromHandModel(
                        player: player, // １プレイヤーが
                        place: right); // 右の
                this.ScheduleRegister.AddWithinScheduler(player, spanModel);
            }
            {
                // ２プレイヤーが、ピックアップ中の場札を抜いて、左の台札へ積み上げる
                var player = 1;
                var spanModel = new MoveCardToCenterStackFromHandModel(
                        player: player, // ２プレイヤーが
                        place: left); // 左の;
                this.ScheduleRegister.AddWithinScheduler(player, spanModel);
            }
        }

        // 対局開始の合図
        {
            var spanModel = new SetGameActive(
                isGameActive: true);

            {
                var player = 0; // どっちでもいいが、とりあえず、プレイヤー１に　合図を出させる
                this.ScheduleRegister.AddWithinScheduler(player, spanModel);
            }
            {
                var player = 1; // プレイヤー２も、間を合わせる
                this.ScheduleRegister.AddScheduleSeconds(
                    player: player,
                    seconds: new GuiOfTimedCommandArgs.Model(spanModel).Duration);
            }
        }

        // 以下、デモ・プレイを登録
        // SetupDemo();

        // OnTick を 1.0 秒後に呼び出し、以降は tickSeconds 秒毎に実行
        InvokeRepeating(nameof(OnTick), 1.0f, tickSeconds);
    }

「　👆　対局開始コマンド というのを追加した。
これがないと　コンピューターが　ゲーム起動直後から　台札置くのも　すっとばして　場札をいじりだしてしまうぜ」

📺 開発中画面

「　👆　とりあえず　こんなもんで」

「　今日は　ここまでだぜ」

📅 2023-02-12 sun 17:52

「　１プレイヤーと　２プレイヤーのどちらも　カードを置けなくなったら、どうすんだっけ？」

「　いっせー　のー　せっ！　の掛け声で一緒に出すんじゃないの？」

📖 遊びかた：スピード

「　👆　手札から補充する、手札がなければ　場札から補充する、とあるぜ」

「　じゃあ、どちらも置けなくなったら、以下のケースがあるわけだぜ」

「　手札が残っている方は、手札の頂上から１枚　自動的に　出す」

「　手札が残っていない方は、場札を１枚　手動的に選んで　出す」

「　後出しが　できるんじゃない？」

「　出さない、というケースもあるのでは？」

「　どちらかが　カード出したら、残っている方は、３秒後に　ピックアップしてる場札　勝手に出す、ということで　いいのでは？」

「　カウントダウン　作んなきゃいけないわね」

「　じゃあ、置く札がない状況、仮に ステイルメイト（Stalemate）　とでも呼ぶとして、
Stalemate かどうか判断する関数を１つ作ろうぜ？」

📅 2023-02-12 sun 18:07 ↑

「　👆　その前にこの　画面サイズに関係なく　ボタンサイズがある、という
GUI　なんとかならないの？」

「　画面サイズが縮んだのなら、ボタンも縮むべきだろ」

「　👆　UI レイヤーのこと　よく分かってないのよね」

📖 複数の解像度のための UI 設計

「　👆　勉強しようぜ」

「　Canvas Scaler コンポーネントというものがあるらしい。なんだぜそれ？」

📖 Canvas Scaler

「　👆　スクリプトなのかな？」

📅 2023-02-12 sun 18:35

「　👆　追加しようと思ったけど、もう追加されてた……」

📅 2023-02-12 sun 18:39

「　👆　Scale with Screen Size にしたら　いいのかな？」

📅 2023-02-12 sun 18:42

「　👆　とりあえず　これで」

ゲーム開始処理の変更

📅 2023-02-12 sun 21:11

「　ゲーム開始処理を　ごっそり　変えたので説明する」

「　👆　大まかに、スクリプトを　ThinkingEngine と Vision に分けることにする。
ThinkingEngine というのは画面なしで動くようなもので、
Vision というのは画面で動くようなゲームが入ってるところだぜ」

「　その Vision の中は、さらに３つに分けることにする。
Input というのはキーボードからの入力だな。
UserInterface というのは、画面上のボタンとかだぜ。
World は、まあ　その他　ぐらいに思えだぜ」

「　👆　今までは　勝手にゲームが始まっていたが、
StartGame() メソッドを呼び出すまで　始まらないように変更する」

「　👆　じゃあ　どこで始まるの？　というと、
ボタンを押したときに　始まるようにする。
これらは Assets.Scripts.Vision.UserInterface.Manager クラスにまとめてある」

「　👆　ボタンを押すと On Click() のリストに登録したメソッドが実行される仕組みは　覚えておいてくれだぜ」

「　👆　開始時のカードも片づけたぜ」

📺 開発中画面

「　👆　今日は　ここまでだぜ」

📅 2023-02-12 sun 21:36 end

📅2023-03-17 fri 21:00

「　おっ、１か月ぶりか。
Unity の画面を見るのも嫌になってるが、
既知の不具合を１つ　直そうぜ？」

「　👆　入力したことを　そのまま実行されると
おかしくなることがあるので、制約を付けたいんだぜ」

「　場札が１枚のときは、左には場札は無いしな」

「　👆　行動に制約を付けると　こんな感じだぜ」

「　制約は　そんなもんで　いいんじゃないの？」

「　👆　それより　ステールメート（※置けるカードがない）したら　どうすんの？」

「　カードを引きたくても、手札（自分の側に積んでいたカード）も　無くなってるぜ」

「　スピードのルールかあ。調べるかだぜ」

📖 トランプ【スピード】のルールを教えてくだし。

「　👆　せーの、で　場札の好きなカードを１枚　捨てれるみたいだな」

「　今、ステールメートしてるかどうか判定するアルゴリズムを書いてくれだぜ」

「　大変なんで、また今度な」

📅2023-03-18 sat 12:41 - Stalemate

「　気分乗らないけど、
ステールメートしてるかどうか　判定するアルゴリズムを考えるか……」

「　メソッドのシグニチャーから　決めたらいいんじゃない？」

入力：
　　1P の場札
　　2P の場札
　　右の台札
　　左の台札
出力：
　　Yes／No

「　👆　まあ、こんなもんだろ。
次は中身だな」

置ける数の配列＝［
　　（右札の台札の数＋１ー１）　mod　１３，
　　（右札の台札の数ー１ー１）　mod　１３，
　　（左札の台札の数＋１ー１）　mod　１３，
　　（左札の台札の数ー１ー１）　mod　１３］

「　👆　最小２つ～最大４つの数を、プレイヤーのどっちかが持ってれば　結果は　No　だぜ」

「　１Pの場札、２Pの場札を　愚直に調べるしかないかだぜ？」

「　場札は　１００枚も無いでしょ。愚直で　すぐよ」

Assets/Scripts/ThinkingEngine/Model/LegalMove.cs:

namespace Assets.Scripts.ThinkingEngine.Model
{
    internal class LegalMove
    {
        // - メソッド

        internal static bool CanPutToCenterStack(GameModel gameModel, int player, int place)
        {
            int index = gameModel.GetIndexOfFocusedCardOfPlayer(player);
            if (index == -1)
            {
                return false;
            }

            IdOfPlayingCards topCard = gameModel.GetLastCardOfCenterStack(place);
            if (topCard == IdOfPlayingCards.None)
            {
                return false;
            }

            var numberOfPickup = gameModel.GetCardsOfPlayerHand(player)[index].Number();
            int numberOfTopCard = topCard.Number();

            // とりあえず差分を取る。
            // 負数が出ると、負数の剰余はプログラムによって結果が異なるので、面倒だ。
            // 割る数を先に足しておけば、剰余をしても負数にはならない
            int divisor = 13; // 法
            int remainder = (numberOfTopCard - numberOfPickup + divisor) % divisor;

            return remainder == 1 || remainder == divisor - 1;
        }
    }
}

「　👆　台札に置けるか、というメソッドをもう作ってあった。これを使えばいいだけかも」

「　じゃあ使えだぜ」

「　👆　ステールメートの判定は、インプット・マネージャーに書けばいいかな」

「　👆　TODO コメントを使って　日本語でプログラムのプレースホルダーを書いていくぜ」

📅 2023-03-18 sat 13:39

「　👆　既存のコードと同じものを２回書くぐらいなら、共通化するぜ」

「　カウント・ダウン・タイマーという　新しい要素を　追加しないといけないわよ？」

「　コルーチンで作れるかな？　大変そうだな……」

「　手札があるときは、手札の天辺の札を取れよ。忘れるなよ」

📅 2023-03-18 sat 18:10

「　開始と終了の位置を線形補間する Lerp はあるけど、
カウントダウンして　時間が来たら　強制的にカードを台札に置くような
仕掛けは　作ってないんだが」

「　コルーチンを使えだぜ」

「　カウントダウンが　インプット・マネージャーの仕事とは思わん。
ユーザー・インターフェース・マネージャーに　カウントダウンをやらせて、
インプット・マネーシャーから　ユーザー・インターフェース・マネージャーへ依頼する形にしようかな」

「　お互いにおけるカードがなくなったから、カードを置き直すの、名前　何かあるのかだぜ？」

「　分かんないから　再開（Reopening）でいいんじゃないの？」

「　じゃあ　それで」

コルーチン

📖 【Unity基礎】コルーチンの使い方と注意点まとめ徹底解説

「　👆　復習しよ」

ステールメート書き直し

「　あれ、ステールメート判定　できてないぜ。
持ってるカードだけ見て　ステールメートを判定しちゃいけないんだ、
場札を全部見ないといけないんだ」

「　書き直せだぜ」

📅 2023-03-18 sat 20:05

「　プログラミングが大変になってきたので、
改造するぜ」

Assets.Scripts.ThinkingEngine.Models.Player.cs :

namespace Assets.Scripts.ThinkingEngine.Models
{
    /// 
    /// プレイヤーの配列の添え字
    /// 
    /// - プレイヤー1 は 0
    /// - プレイヤー2 は 1
    /// 
    class Player
    {
        // - 演算子のオーバーロード

        #region 演算子のオーバーロード（== と !=）
        // 📖 [自作クラスの演算子をオーバーロードする](https://dobon.net/vb/dotnet/beginner/operator.html)
        // 📖 [自作クラスのEqualsメソッドをオーバーライドして、等価の定義を変更する](https://dobon.net/vb/dotnet/beginner/equals.html)

        public static bool operator ==(Player c1, Player c2)
        {
            // nullの確認（構造体のようにNULLにならない型では不要）
            // 両方nullか（参照元が同じか）
            // (c1 == c2)とすると、無限ループ
            if (object.ReferenceEquals(c1, c2))
            {
                return true;
            }

            // どちらかがnullか
            // (c1 == null)とすると、無限ループ
            if (((object)c1 == null) || ((object)c2 == null))
            {
                return false;
            }

            return (c1.source == c2.source) && (c1.source == c2.source);
        }

        public static bool operator !=(Player c1, Player c2)
        {
            // (c1 != c2)とすると、無限ループ
            return !(c1 == c2);
        }

        /// 
        /// objと自分自身が等価のときはtrueを返す
        /// 
        /// 
        /// 
        public override bool Equals(object obj)
        {
            //objがnullか、型が違うときは、等価でない
            if (obj == null || this.GetType() != obj.GetType())
            {
                return false;
            }
            //この型が継承できないクラスや構造体であれば、次のようにできる
            //if (!(obj is TestClass))

            //Numberで比較する
            Player c = (Player)obj;
            return (this.source == c.source);
            //または、
            //return (this.Number.Equals(c.Number));
        }

        //Equalsがtrueを返すときに同じ値を返す
        public override int GetHashCode()
        {
            return this.source;
        }
        #endregion

        // - その他

        internal Player(int source)
        {
            this.source = source;
        }

        // - フィールド

        /// 
        /// 値
        /// 
        int source;

        // - プロパティー

        /// 
        /// 整数型形式で取得
        /// 
        internal int AsInt => source;
    }
}

「　👆　プレイヤーを　int　型で表すのは　辛くなってきたので
クラスを使って　Player型　を作るぜ。
C# に typedef は無い」

「　勝手にしろだぜ」

Assets.Scripts.ThinkingEngine.Commons.cs :

namespace Assets.Scripts.ThinkingEngine
{
    using Assets.Scripts.ThinkingEngine.Models;

    /// 
    /// よく使う不変値
    /// 
    static class Commons
    {
        internal static readonly Player Player1 = new Player(0);
        internal static readonly Player Player2 = new Player(1);
        internal static readonly Player[] Players = new Player[]
        {
            Player1,
            Player2,
        };
    }
}

「　👆　よく使う値を　予め作っておくぜ」

📅 2023-03-18 sat 22:45

Assets/Scripts/Vision/Input/Manager.cs :

            // ステールメートしてるかどうかの判定
            // ==================================

            // ステールメートしているとき
            bool isStalemate = true;
            // 反例を探す
            foreach (var playerObj in Commons.Players)
            {
                foreach (var centerStackPlace in Commons.CenterStacks)
                {
                    var max = this.gameModel.GetCardsOfPlayerHand(playerObj).Count;
                    for (int i = 0; i < max; i++)
                    {
                        if (LegalMove.CanPutToCenterStack(
                            this.gameModel,
                            playerObj,
                            new HandCardIndex(i),
                            centerStackPlace))
                        {
                            isStalemate = false;
                            goto end_loop;
                        }
                    }
                }
            }
        end_loop:

            if (isStalemate)
            {
                // TODO ★ カウントダウン・タイマーを表示。０になったら、ピックアップ中の場札を強制的に台札へ置く
                this.reopeningManager.DoIt();
            }

「　👆　コードの掲載は　省いていくが、雰囲気は　こんな感じ」

📺 開発中画面

📅 2023-03-18 sat 23:49

「　👆　そのあと　大改造して　カウントダウンは　付けたぜ。
今日はここまで」

📅 2023-03-19 sun 17:58

「　Unity の顔を見るのも嫌になっているが　不具合の調査をするかだぜ」

「　ゲームの結果を表示してくれだぜ。
1Pの勝ち、2Pの勝ち、引き分け　のいずれかだろ」

「　両プレイヤーが　同時に最後のカードを　捨てるの、
何ミリ秒差まで　厳密に判定するの？
一瞬でも速く置いた方が　勝ちなの？」

「　レトロな　格闘ゲーマーは　１フレームの差を　文句言ってくるからな」

「　じゃあ　１フレームの差を区別しろだぜ。
両者が　最後の１枚を残して　ステールメートしてるときは　同時にカード捨てるから　引き分けになるぜ」

「　カードを捨てた瞬間か、
それとも　カードを台札に置いた瞬間か、
どっちで判定するんだぜ？」

「　カードを置いた瞬間よ」

「　カードを置いた瞬間って、どんな瞬間？」

「　台札の鉄板のカードに、場札が接した瞬間よ」

「　デジタルゲーなのに　判定は　アナログ的なの　つら」

「　Unity は物理的な当たり判定を取れるのでは？」

「　物理演算を使うと、距離とか　速度とか　公平性　保たなくてはいけなくなって大変なので
デジタルな判定にしたいぜ」

「　台札に投げたカードの　モーションの終点で　フラグ立てるか」

📅 2023-03-22 wed 19:14

「　これから　風呂入って　ビール飲んで　まだやる気があったら　開発するぜ」

「　開発ブログやる気無くなってるの　わらう」

📅 2023-03-23 thu 19:35

「　はあ～　Unity の顔も見たくねー、起動だけ　するか～」

「　やる気がない時期を　やりすごすのが　長く続けるには　重要なのよ」

📅 2023-03-23 thu 23:11

「　ソースコードを掃除した。今日は終わり」

📅 2023-03-25 sat 16:25

「　今日はプログラミングすんの？」

「　待ってくれだぜ　つら。
ジュース飲んで　気分が上がってくれば　プログラミングするぜ」

📅 2023-03-26 sat 13:56

「　気分が乗ったら　プログラミングするぜ」

「　起動する元気も大事だしな」

// 書きかけ

Unityで〇×ゲームを作ろうぜ（＾～＾）？

2023-01-17T23:44:33+09:00

教育目的

プログラミング・スキルの普及のために、 この記事の内容は　改変・転載許可

成果物： 📖 Tic tac toe
コード： 📖 Tic-Tac-Toe

📅2023-01-17 tue

📖 アマゾン創業者が部下に繰り返し続けた「過酷な一言」

「　👆　ジェフ・ペゾスは　モックアップの時点で完成度高くないと　企画も通さないらしいぜ。迷惑だよな」

「　どう迷惑を受けたんだぜ？」

「　モックアップ作りから妥協しない姿勢が　Amazon の強さの秘訣だ、みたいな論調の記事を読むと
だったら　もう　モックアップ作るの　いいかな、　弱くていいや、　と　なにもかも　嫌になってしまう」

「　個人サークルの１人が言う　モックアップ　と、
１４０万人ほどの社員がいる企業の社長が言う　モックアップ　を同じように扱おうとするのが　性格が意固地なのよ。
モックアップに完成度を求めていないケースだってあるのだから、
特定の社長に最適化せず　もっと言葉を適当に使えばいいのよ」

「　これより　Unity を使って　〇×ゲームの やっつけモックアップ を作る。
今回の趣旨は　技術　を何も説明せず、　雰囲気　で書く　ヒカルの碁方式　だぜ」

「　Qiita と Zenn で規約違反になるから　Crieit でやるのか」

「　いや、思想違反」

「　ガイドラインぐらい　程度は違えど　どこにでもあるのだから　守ればいいのよ」

「　👆 これ、 Unity Hub （ユニティハブ）。
なんか並んでる１つ１つは　レッスンの残骸とか、　手指の練習の残骸とか、　まあゲーム１個分の何かだぜ」

「　なるほど　画面を見せていくわけか　YouTube でやれだぜ」

「　嫌だぜ」

「　👆 最初は　とにかく　プロジェクト名　を付けろだぜ。
偉いさんは　SEO　や　name conventions　を考えた　いい感じの名前を　付けたいと考えるかもしれないが
わたしの流儀は　『あの世に持っていけるものは何もなし』　だぜ。　ひねらず　付けて　進め」

「　現世利益に興味を持てだぜ」

「　墓碑銘は　『墓』　にしましょう」

「　👆 プロジェクトを開くと　Unity Editor（ユニティー・エディター）が出てくる。
わたしは　4K（よんけー）ディスプレイ　を使っているので　大きな添付画像になってしまうから、
以降は　適当にウィンドウを縮めて　スクリーンショットを貼っていくぜ」

「　そこらへんの You Tube でゲーム開発動画が　たくさんあるから　読者諸君は　詳しくは勝手にググれだぜ」

「　👆 〇×ゲーム作るんだったら　盤が要るだろ。　平面（へいめん；Plane プレーン）を置こうぜ？」

「　ぜったい　Unity Learn で企画書を書けだの、設計を練れだのレッスン受けたのにな。
プログラマー・スキル・レベル剥奪だぜ」

「　設計を 信じて ないのよ。　プロジェクトは崩壊すると思ってるから」

「　じゃあ　お父んは何を信じて　Unity Editor　なんか開いたのか？」

「　あっ、そういえば　〇　も　×　も　素材が無いぜ！」

「　👆 わたしにはモデルを作るスキル無いので Windows Paint で描くぜ」

「　行き当たりばったりだな」

「　行動してから考える人 ですからね」

「　お父んの頭の中に効率と戦略が無いことは分かった」

「　👆 画像をプレーンに　ドラッグ＆ドロップ　すれば　テクスチャーを貼るの完了だぜ」

「　Unity、 3Dが得意なのに　ペラペラの平面に Windows Paint の画像貼り付けるの
Unity の無駄遣いだよな」

「　まだ 行動の途中 で、 考える ところまで　行ってませんからね」

「　そう言えば、盤に　黒くて太い線を引きたいけど、　黒い太線を引くのも　めんどくさいんだよな。
それに　盤のマスをクリックしたかどうか　範囲を調べるのも　めんどくさい……」

「　👆 そこでプレーンを９枚置いて、マスの代わりとしようぜ！」

「　お父んの優先順位の中で、 アートワーク の順位は下の方にあることが分かった」

「　花より団子 の人ですからね。　〇×ゲームができれば　なんでもいいのよ」

「　しかし　どういう感じにすりゃ　〇×ゲーム　を作れるのか　よく分からんな」

「　👆 ここで一旦　プロジェクトを保存して　Unity Editor を終了するぜ」

「　考えるのをやめたか」

「　👆 わたしの Git Hub を開くんだぜ」

「　ソースを　クラウドに保存するんだな」

「　👆 クラウド上に　リポジトリを作るぜ。　リポジトリというのは　ファイル置き場　ぐらいの意味だぜ」

「　👆 GitHub Desktop for Windows というデスクトップ・アプリケーションと連動するんで、
ローカルPCのさっきの Tic-Tac-Toe のファイルを、
いったんローカルPC側のリポジトリでコミットし、
続いてクラウド上のリポジトリへプッシュするぜ」

「　何を言っているか分からないが　まあ　がんばれだぜ」

「　👆 リモートにファイルが置かれたな」

「　本当は コード・レビュー を入れて、コメントをちゃんと書いてコミットして使うものなんだけど、
やらないのよ」

「　やらないだろうな」

「　ドカスカ　プッシュしろだぜ」

「　Git Hub にソースをプッシュしたから、
ソースを壊してしまったときは　それより前のバージョンへ　巻き戻すことが可能になったわね」

「　適当に　どこかに戻せれば　十分だぜ」

「　戻してから考える んだろうなあ」

「　👆 マス（※英語でSquare スクウェア）をマウスでクリックしたときに　〇×を付けたいんだろ。
とりあえず Square という名前で C#（しーしゃーぷ）スクリプトを作ろうぜ？」

「　Git Hub で、いつでもリセットできるから　お父んの とりあえず進もうぜ、困ったら戻ろうぜ法 が完成だな」

「　頼りない名前の法だなあ」

補足：📖Unity 2020でスクリプトの日本語が文字化けするのを修正する

「　👆 これが Visual Studio 2022 （びじゅある　すたじお　にせんにじゅうに）というデスクトップ・アプリケーションだぜ。
こんな画面出てきても、これから何かけばいいか分からないだろ」

「　何でも書いたらいいんじゃないか」

「　👆 そう！
何もないところのうち　いい感じのところに mouse と打鍵すれば、
わたしが書きたいものを予測して候補が出てくる。これが Visual Studio の利点であるインテリセンス（IntelliSense）という AI だぜ。
1990年代後半にはすでにあった」

「　👆 そしてその候補で合ってたら、キーボード上の tab キーを１回押せだぜ。
スケルトン・コードを書いてくれる。
スケルトンというのは、穴埋め文章の穴じゃない方だな」

「　適当の達人だな」

「　いい感じのところ がどこなのか説明してくれないから　真似するの無理よ」

「　👆 何書けばいいか分からないから、とりあえず Debug.Log("なんちゃら") を書けだぜ。
このテクは　デバッグ・ライト（Debug write）と言う」

「　とりあえず が多いな」

「　👆 で、スクリプトは書いただけでは動かない。
マス（※画面上では Square 0 ～ Square 8）というゲーム・オブジェクトに Square スクリプトを持たせる。
この操作を アタッチ (Attach) と呼ぶ」

「　👆 カメラの位置も　あんまりだったので、 Main Camera の位置を調整する」

「　👆 ゲーム・ビューも好きなようにいじって、 Unity Editor の上の方に置いてある再生ボタンを押せだぜ」

「　👆 するとゲーム画面になる。
黄緑色のマスをクリックしたら、 Unity Editor の左下に『マウスボタンを押しました』と出てきた。
これで動作確認完了だぜ」

「　マスがクリックできることまでは　分かったな。
そこから　どうするのか　分からんけど」

「　クリックしたマスの上に　〇のカード　が飛んでくりゃ　よくない？」

「　じゃあ　〇のカード ５枚、 ×のカード ４枚を予め作っておけばいいのかだぜ？」

「　めんどくさ……。マスの表面のテクスチャーを貼り替えりゃよくないかだぜ？」

「　あらゆる発想が　めんどくささに　飲み込まれて　消えていくわね」

「　お父ん　ぜったい　あらゆる企画マンと　会話　合わないよな」

「　👆 とりあえず GameManager C#スクリプトをアタッチした Game Manager ゲーム・オブジェクトを作れだぜ」

「　👆 GameManager C#スクリプトの　いい感じのところに、　いい感じに　マテリアルを３つ書くと」

「　👆 マテリアルを　ドラッグ＆ドロップで　設定できる欄が　できるから」

「　👆 がんばって　ドラッグ＆ドロップ　しろだぜ」

「　👆 Nought ゲーム・オブジェクトと、 Cross ゲーム・オブジェクトは　結局使わないので　消せだぜ」

「　行き当たりばったりの　ひずみ　ここに出るの　わらう」

「　バーチャル空間だから　無駄な発注を　やりたい放題よ　徒労が増えるだけで」

「　👆 GameObject C#スクリプトに　実質５行ほど　コードを書き足したぜ」

「　👆 Square C#スクリプトに　実質４行ほど　コードを書き足したり、編集したりしたぜ」

「　なんの説明もないところが　今回の記事の趣旨だな」

「　👆 だが、もう　○、×　を交互に置けるぜ」

「　👆 もう印を置いてあるところを　またクリックして　印を変えることができるぜ」

「　👆 イリーガル・ムーブ（非合法手）のチェックはしてないからな」

「　しなきゃ　いけなくない？」

「　プロフェッショナルなプログラマーなら　必ず　修正するし、
レッスン中なら　不具合の修正は　ほっといて　後回しにしろだぜ。
不具合の修正は　気持ちが乗らないからな」

「　不具合の修正より、気持ちがノるか　ノらないかが　優先されるのね」

「　ぜったい　わらう」

📅2023-01-18 wed

「　👆 勝ったとき　『勝ち！』　って出てくれば　気持ちがノるだろ。
まずは　その前に　勝ったかどうか判定するプログラムを書こうぜ？」

「　プログラムらしい話に進むな」

📅2023-01-20 fri

「　👆 テキストをまず作っておこうぜ。
普段は非表示にしておいて、必要な時に表示すればいい」

「　仕込みだな」

「　👆 勝敗判定を　どこに　どういう風に書けばいいのか分からない。
分からなかったら　なんとかManager C# スクリプトを作って、　なんとか Manager ゲーム・オブジェクトにアタッチすればいいぜ」

「　お父んは『いいぜ』と言うが、　ダメだったら戻ればいいスタイルだからな」

「　迷路をとりあえず進んでるだけよね」

「　👆 Position （ポジション） C# スクリプトもいるかもしれない。スケルトンを置いておこう」

「　要るか　要らないか　分からなくても　スケルトンを置くのが　お父んの開発スタイルだよな」

「　👆 Piece （ピース；駒）イナム（enum；列挙）型も作っとこ。　あとで使うだろ」

「　どんどんタネを仕込んで　あとで　組み合わせる　やり方か」

「　ちゃんと　組み合わさるか　事前に検討して　必要なものだけを洗い出すステップを　やらないのよ、　ノらないから」

「　👆 ポジションに Piece 型の配列を持たせようぜ。
これ、 Unity Editor で　いじれるようにしようかな、 [SerializeField] アノテーション付けたろ」

「　👆 やっぱ Position Manager ゲーム・オブジェクトも作って Position C#スクリプトをアタッチしようぜ？
盤を編集でけて　お得だろ」

「　お得かどうかは関係ないんじゃないか？　損だったら戻ればいいのだから　進めば」

「　最後に　まとめ切れるかどうか　関係無いですからね、この開発手法」

「　👆 Position は Clear 関数や、 SetPiece 関数を使うだろ。
class の public 修飾子も消して internal アクセスにしておこうぜ。
Linq はパフォーマンスが心配なんで使わないぜ」

「　それが　何かの説明は　しないんだな」

「　👆 GameManager C#スクリプトに入ってた movesCount フィールドは、 Position クラスにあった方がいいので　移動した。
MovesCount アクセッサ―も追加したぜ」

「　👆 movesCount フィールドを Position クラスに持っていかれた GameManager クラスの方には、
Position インスタンスにアクセスできるようにプロパティを用意し、参照箇所も Position プロパティに変更するぜ」

「　フーン」

「　👆 Square 0 ゲーム・オブジェクトの 0 の部分だけ取るように正規表現（せいきひょうげん；RegularExpression）を書き、
Position インスタンスにセットするように書いてみた」

「　へぇ」

「　👆 これで、マスをクリックすると、○と×が入っているのが分かるな」

「　Cross （×）と Nought （○）が逆よ」

「　ぬぎぎぎぎ！」

「　👆　インクリメントは最後にやれだぜ！」

「　👆　Position インスタンスが盤を表している。
Element 1 と Element 4 と Element 7 に Nought が入っていれば、３つの○が並んだということだぜ」

「　タテ、ヨコ、ナナメに同じピースが３つ並んでいることを判定できる数式があるの？」

「　○×ゲームぐらいの　盤サイズの小ささなら　全パターン網羅して　ハードコーディングしたった方が早いぜ」

「　👆　Position クラスに GetPiece メソッドが無いと盤のマスを見れないので追加する」

「　👆　例えば３つ並んだケースの一覧とか要るだろ。
要ると思ったものを　予め　作っておくんだぜ」

「　要ると分かってから　作った方が良くないか？」

「　ノらないから　そんなこと　しないのよ」

「　👆　対局結果も要りそうだ。作っとこ」

「　この開発手法では　工数の見積もりを取れないのでは？」

「　設計してないんだから　見積もりがあるはずないじゃない」

「　👆　勝敗判定を書いている途中に思ったんだが、負けかどうかは判定してないな」

「　じゃあ　『勝敗判定』ではなくて　『勝ったか判定』だぜ」

「　👆　対局結果から　負け　を削除しとこ。
GameResult も　こっそり GameResults に変えた」

「　勝ち　しか無かったら、どっちが勝ったのか　分からなくない？」

「　👆　まさか　Lose　を使う必要がないとは　思わなかったぜ」

「　ダメだったら戻ればいい　の現場だな」

「　👆　JudgeManager で対局結果を見れたら　デバッグが楽だと思ったから　フィールドと　プロパティ付けたろ。
winPatterns も　こっそり static readonly 付けたろ」

「　👆　対局結果を返すのではなく、対局結果をフィールドに入れるように変更。
名前も DoJudge から SetupJudge に変更」

「　👆　GameManager クラスの中で JudgeManager インスタンスの SetupJudge メソッドを使ってみよう」

「　👆　ちゃんと Win が入ってるな」

「　👆　でも Draw 判定が 10手目にされたので　1　引いとこ」

「　１０手目なんか　無いんだけどな」

「　👆　対局結果のゲーム・オブジェクトのアクティベートのチェックを外して、存在していないことにしよ」

「　👆　存在しないゲーム・オブジェクトだったら、 Unity は見つけられないので、
[SerializeField] アノテーションを利用して　ゲーム・オブジェクトにアクセスする仕組みを　仕込むぜ。
ついでに SetActive( ) メソッドを使って、ゲーム・オブジェクトのアクティベートのチェックを入れるコードも書いておくぜ」

「　👆　ドラッグ＆ドロップしておくぜ」

「　👆　対局結果が出るようになったぜ」

「　配色わる」

「　文字のような○×の上に　文字　出してるしな」

「　他の　盤ゲームが　対局結果を　どう表示しているか　見てこいだぜ」

「　👆　わたしに美術はできないので、終局時に　半透明のフロント・カバーが　かかるようにしよう！」

「　確かに　お父んは　企画　通らなさそう」

「　👆　これで　十分　十分」

「　ビデオゲームは　見た目のできが　内容のできだと　思われるのよ」

「　ノらないところは　やらないでおこうぜ？」

「　他の人はむしろ　目に付く　見た目を　いじりたがるんだけどな」

「　次は　リスタート・ボタン　を付けようぜ？」

📅2023-01-21 sat 00:31 end

📅2023-01-22 sun 01:34 start

「　👆　2020年代の GUI というと Web クライアントや、 Windows デスクトップ・アプリケーションでは進歩、淘汰の激戦区だが、
Unity に付いてる GUI は 1990年代かな、というぐらいクラシックなものなので　あまり気合を入れずに使うぜ」

「　👆　リスタート・ボタンの見た目は　こんなんでいいんじゃないか？」

「　美術の欠如している　わたしたちは　これでいきましょう」

「　👆　JudgeManager に Clear メソッドを付けるぜ」

「　👆　Position の Clear メソッドで moveCount フィールドを　ゼロ初期化してなかったので　するぜ」

「　仕込みをしてるんだな」

「　👆　GameManager に Clear メソッドを付けるぜ。
この中で　Position インスタンスと、 JudgeManager インスタンスの Clear メソッドを呼び出すとともに、
対局結果のテキストと、盤に被せた半透明の幕のアクティベートのチェックを外して、ゲーム中に存在しない扱いにするぜ」

「　👆　また、 Start メソッドで Clear メソッドを呼び出した」

「　それは要るのか？」

「　シーン・ビューで　テキストの表示のアクティベートのチェックを外すの忘れたりしたまま　リリース　したくないだろ」

「　👆　ボタンを押したら、 Game Manager ゲーム・オブジェクトの持っている GameManager C#スクリプトの Clear メソッドが
呼び出されるように　マウス操作で紐づけるぜ。
この技術の名前は　イベント・リスナー（Event Listener）だぜ」

「　👆　リスタート・ボタン自体のアクティベートのチェックを　オン／オフする仕組みを忘れてた　追加しよ」

「　👆　だんだん　ごつく　なってきたな」

「　👆　でも　リスタート・ボタンが出てきたぜ。押してみよ」

「　👆　盤はクリアーされてないぜ？　なぜだぜ？」

「　WPF （ダブリュー・ピー・エフ）の MVVM （エム・ブイ・ブイ・エム）の ViewModel （ビュー・モデル）に慣れた癖で忘れていたが、
Unity ではデータをクリアーしても、シーンは連動していないのだった」

「　これは　ゲーム・プログラミングなのよ。
デスクトップ・アプリケーションのような　処理が重たい技術は　流行らないのよ」

「　👆　マスの材質を　緑色の素材に貼り替えたろ」

「　👆　貼り替わったぜ」

「　これで　○×ゲームは　卒業かだぜ？」

「　まだ　イリーガル・ムーブ　を禁止していないわよ？」

「　👆　じゃあ　バリデーター（Validator）を作ればいいだろ。
そのマスに置けるかどうかだけ　チェックすればいいのかだぜ？」

「　👆　あっ、　Square 0 みたいなゲーム・オブジェクトの名前しか取れね。 0 みたいなマス番号取れね」

「　不便よねえ」

「　👆　じゃあ　ヘルパー関数　作ればいいんだぜ。
GameManager で　似たようなコード前に作ったから　引っこ抜いて　共通利用できるようにするぜ」

「　👆　既存のコードは見やすくなるし」

「　👆　新しいコードは書きやすくなる」

「　👆　これで　非合法手　は防げたんじゃないか？」

「　Nought win のあとに　まだ　X を置けるんじゃない？」

「　👆　半透明の青い膜が被っていて、　マスはクリックできないから
対局終了後に　マスをクリックすることは　でけないぜ」

「　じゃあ　いいかあ」

「　これで　完成か？」

「　コード・レビュー　しようぜ？
プログラミングの　へたくそなところがある」

「　👆　例えば　『駒を置く』は入力だが、　『対局結果を表示する』は出力だぜ。
入力メソッドが　出力してるなんて　イケてないぜ」

「　判断基準は　イケてるか　イケてないか　なのね」

「　プログラマーの気分　を　重要視してるんだな。　その点では Ruby に似ているな。お父んのポリシーが　分かってきたぜ」

「　👆　『出力』の部分を DoMove メソッドから外に出したいが、
piece 変数が DoMove メソッドに束縛されているから、 piece 変数を自由変数に変える方法を考えようぜ」

「　なんだか分からないが　任せたぜ」

「　👆　Position クラスに手番（Turn）を持たせようぜ。
初期値は Nought」

「　👆　手番を追加する NextTurn メソッドもいるや。追加しとこ」

「　👆　インクリメントも NextTurn メソッドの中で　やってまお。
MovesCount プロパティーのセッター（set）も要らなくなったから、短く書いたろ」

「　👆　これで DoMove の中から piece 変数が消えた。代わりに Position に依存するようになったぜ」

「　👆　こうやって UpdateGameResultView メソッドに切り分けることがでけたな。
しかし DoMove メソッドを実行すると UpdateGameResultView メソッドまで　実行されてしまうのは　イケてないな」

「　👆　あっ　いけね！
対局が終了しているときは　NextTurn しないように　バリデーション・チェックしようぜ」

「　👆　JudgeManagement クラスの SetupJudge メソッドを、
変更があったかどうか返すように　変更するぜ」

「　👆　判定に変更があれば dirtyJudgement フラグを立て、
dirtyJudgement フラグが立っているときだけ UpdateGameResultView メソッドは働き、
働いたら dirtyJudgement フラグは下ろす、という風に作るぜ」

「　めんどくさ」

「　👆　これで UpdateGameResultView メソッドの呼び出しを
DoMove メソッドの外に出して、
Update メソッドの中へ　引っ越すことがでけたぜ」

「　👆　そんなけ　コードをいじっても　ゲームは何にも変わらないじゃない。
コードを　イケてるようにすることに　何の意味があんの？」

「　ワザを安定して出せるようになると、
もっと　大きなワザ　を出せるようになる。大きなワザ　を出せるようにするために　コードを掃除してるんだぜ」

「　👆　GameManager クラスの Clear メソッドの中で　画面表示を切り替えているのは　掃除しないのかだぜ？」

「　する」

「　👆　Position クラスの SetPiece メソッドも、変更があったかどうか返すようにしようぜ？」

「　👆　マスをクリックして、絵柄に変化があったときだけ dirtySquares セットに　マス番号を追加することにするぜ」

「　👆　これで　DoMove メソッドの中から　表示をコントロールするコードは　消えてなくなっただろ」

「　入力メソッドの中では　出力はしないようにしたんだな」

「　dirtyなんちゃら フラグが　入力メソッドと　出力メソッドの　橋渡しをしているのね」

「　👆　GameManager クラスの Clear メソッドの中にあったコードも、 dirty フラグを立てるだけでよくなったぜ」

「　これで　表示周りのコードの　クリーンナップ　は終わりか？」

「　まだある」

「　👆　GameObject.Find メソッドは　処理に時間がかかるらしい。
できれば　Start メソッドで１回使ったあとは　使わなくて済むようにしたいぜ」

「　やってくれだぜ」

「　👆　GameManager クラスの Start メソッドが呼び出された時点で、GameObject.Find を先にしてしまって、
ゲーム・オブジェクトをメモリに入れておけばいいぜ」

「　他に　どこを　クリーンナップ　するんだぜ？」

「　👆　例えば get アクセッサ―で変数をリターンしているだけのプロパティなんかは……」

「　👆　ラムダ式と同じなんだったら、書き方が短いラムダ式にするとかかな。
パフォーマンスに違いがでるのか　知らんけど」

「　パフォーマンスの測定をするほどの　速度が必要なアプリケーションじゃないから
ちょっとぐらいパフォーマンスが違っても　違いは分かんないわねえ」

📅2023-01-22 sun 06:45

「　👆　WebGL 形式で　実行ファイルを出力してみようぜ？」

「　👆　Visual Studio Code に Live Server エクステンション入れてると　ローカルWebサーバー起ちあがるんで、
Tic Tac Toe の index.html を開いてみようぜ？」

「　👆　開けたな」

「　👆　プレイできるぜ」

「　○×ゲームできても　ビデオゲームって感じ　しないけどな」

「　２か月 Unity Lesson でビギナーコースを受けて、○×ゲームを作るのに　３日間かかるようでは　気が遠くなるわよね」

「　仕込みが　なんにも無いからな。
重要なのは　制作進行を覚えて　素材の発注を見積もることだぜ」

「　UI もタイトル画面も何もかもがなくてゲーム開発の全体像はまだ見えないわね」

「　まあ、先に進もうぜ」

📖 Unity Play

「　👆　Unity Play という Web サイトがある」

「　👆　ここには、作ったゲームをアップロードするページがある」

「　👆　というわけで、 WebGL のファイルが入ったフォルダーを .zip 圧縮し……」

📖 Tic tac toe

「　👆　アップロード完了。 Play Unity に置いたぜ」

「　👆　まあ　○×ゲーム　しかできないんだけどな」

📅2023-01-22 sun 07:22 end

＜おわり＞

Unityで複数の入力方法に対応するタイピングゲームを作ろう

2021-03-06T10:10:58+09:00

はじめに

はじめまして、情報系の大学に通っているプログラム初心者の大学生です。

2年前にゼミ内で小さなゲームジャムが開催され、タイピングゲームを作ることになったのですが、ネット上で紹介されている既存のタイピングゲームの制作方法では入力方法に以下のような問題があると思いました。

1. 単語を打つ手段があらかじめ決まっている。
例 : "し"と打つときに"si"と打たなければいけなく、"shi"には対応していない。

2.単語を別々に入力できない。
例 : "ちゃ"と打つときに"ち"と"ゃ"を別々にタイプできない。

そこで今回はどんな打ち方にも対応できるタイピングゲームの制作に挑戦してみました。
この記事では仕組みとプログラムに関して紹介していきます、参考にしていただければ幸いです。

参考にした作品

今回制作したプログラムでは「寿司打」のタイピングシステムを参考にしています。

寿司打

こちらからプレイできます。

どのようなシステムかというと

ゲーム画面ではこのようにタイプする文字と入力方法が表示されています。
この状態で"し"を"si"ではなく"shi"と入力しようとすると...

"sh"と入力した時点で1つ目の"し"の入力方法が"shi"に置き換わります。
(2つ目の"し"の入力方法は変わらず表示されている。)

他にも

"ック"を入力する際に、"xtu"と"ku"で別々に入力しようとすると...

"xtu"の"x"を入力した時点で”ッ”と"ク"を別々と考えて入力方法を置き換えています。

プログラム

筆者なりに上記のシステムを再現しようとすると以下のようなプログラムになりました。

Kanji.txt

タイピングゲーム内で使う文章をそのまま入力します。
一度のタイピングで入力する長さを決めて改行してください。

別に君を求めてないけど
横にいられると思いだす。
君のドルチェ＆ガッパーナの
その香水のせいだよ。

Japanese.txt

Kanji.txtの内容を全てひらがなにして入力してください。

べつにきみをもとめてないけど
よこにいられるとおもいだす。
きみのどるちぇあんどがっぱーなの
そのこうすいのせいだよ。

KanjiFuri.txt

Kanji.txt内の文字をひらがなにした時、何文字になるかを入力してください(ひらがなの場合は1)

21212111111
211111121111
2111113111111
1122111112

Dictionary.cs

全ての入力方法を連想配列で整理しています。
下の方にある関数はKeyかValueを渡すことで紐づけられた要素を全て取り出すことができます

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Dictionary : MonoBehaviour
{
    //デフォルトの入力方法
    public readonly Dictionary dic = new Dictionary() {

        {"あ", "a"},{"い", "i"},{"う", "u"},{"え", "e"},{"お", "o"},
        {"か", "ka"},{"き", "ki"},{"く", "ku"},{"け", "ke"},{"こ", "ko"},
        {"さ", "sa"},{"し", "si"},{"す", "su"},{"せ", "se"},{"そ", "so"},
        {"た", "ta"},{"ち", "ti"},{"つ", "tu"},{"て", "te"},{"と", "to"},
        {"な", "na"},{"に", "ni"},{"ぬ", "nu"},{"ね", "ne"},{"の", "no"},
        {"は", "ha"},{"ひ", "hi"},{"ふ", "hu"},{"へ", "he"},{"ほ", "ho"},
        {"ま", "ma"},{"み", "mi"},{"む", "mu"},{"め", "me"},{"も", "mo"},
        {"や", "ya"},{"ゆ", "yu"},{"よ", "yo"},
        {"ら", "ra"},{"り", "ri"},{"る", "ru"},{"れ", "re"},{"ろ", "ro"},
        {"わ", "wa"},{"を", "wo"},{"ん", "n"},
        {"が", "ga"},{"ぎ", "gi"},{"ぐ", "gu"},{"げ", "ge"},{"ご", "go"},
        {"ざ", "za"},{"じ", "zi"},{"ず", "zu"},{"ぜ", "ze"},{"ぞ", "zo"},
        {"だ", "da"},{"ぢ", "di"},{"づ", "du"},{"で", "de"},{"ど", "do"},
        {"ば", "ba"},{"び", "bi"},{"ぶ", "bu"},{"べ", "be"},{"ぼ", "bo"},
        {"ぱ", "pa"},{"ぴ", "pi"},{"ぷ", "pu"},{"ぺ", "pe"},{"ぽ", "po"},
        {"ぁ","xa" },{"ぃ","xi" },{"ぅ","xu" },{"ぇ","xe" },{"ぉ","xo" },
        {"っ", "xtu"},
        {"ゃ","xya" },{"ゅ","xyu" },{"ょ","xyo"},
        {"きゃ","kya"},{"きぃ","kyi"},{"きゅ","kyu"},{"きぇ","kye"},{"きょ","kyo"},
        {"しゃ","sya"},{"しぃ","syi"},{"しゅ","syu"},{"しぇ","she"},{"しょ","syo"},
        {"ちゃ","tya"},{"ちぃ","tyi"},{"ちゅ","tyu"},{"ちぇ","tye"},{"ちょ","tyo"},
        {"にゃ","nya"},{"にぃ","nyi"},{"にゅ","nyu"},{"にぇ","nye"},{"にょ","nyo"},
        {"ひゃ","hya"},{"ひぃ","hyi"},{"ひゅ","hyu"},{"ひぇ","hye"},{"ひょ","hyo"},
        {"みゃ","mya"},{"みぃ","myi"},{"みゅ","myu"},{"みぇ","mye"},{"みょ","myo"},
        {"りゃ","rya"},{"りぃ","ryi"},{"りゅ","ryu"},{"りぇ","rye"},{"りょ","ryo"},
        {"ぎゃ","gya"},{"ぎぃ","gyi"},{"ぎゅ","gyu"},{"ぎぇ","gye"},{"ぎょ","gyo"},
        {"じゃ","zya"},{"じぃ","zhi"},{"じゅ","zyu"},{"じぇ","zye"},{"じょ","zyo"},
        {"ぢゃ","dya"},{"ぢぃ","dyi"},{"ぢゅ","dyu"},{"ぢぇ","dye"},{"ぢょ","dyo"},
        {"びゃ","bya"},{"びぃ","byi"},{"びゅ","byu"},{"びぇ","bye"},{"びょ","byo"},
        {"てゃ","tha"},{"てぃ","thi"},{"てゅ","thu"},{"てぇ","the"},{"てょ","tho"},
        {"うぁ","wha"},{"うぃ","whi"},{"うぇ","whe"},{"うぉ","who"},
        {"でゃ","dha"},{"でぃ","dhi"},{"でゅ","dhu"},{"でぇ","dhe"},{"でょ","dho"},
        {"くぁ","qa"},{"くぃ","qi"},{"くぇ","qe"},{"くぉ","qo"},
        {"ふぁ","fa"},{"ふぃ","fi"},{"ふぇ","fe"},{"ふぉ","fo"},
        {"ヴぁ","va"},{"ヴぃ","vi"},{"ヴ","vu"},{"ヴぇ","ve"},{"ヴぉ","vo"},
        {"ぴゃ","pya"},{"ぴぃ","pyi"},{"ぴゅ","pyu"},{"ぴぇ","pye"},{"ぴょ","pyo"},
        {"、","," },{"。","."},{"「","["},{"」","]"},
    };

    //デフォルトではない入力方法
    public readonly Dictionary Epicdic = new Dictionary()
    {
        {"ca","か" },{"ci","し" },{"cu","く" },{"ce","せ" },{"co","こ" },
        {"cha","ちゃ"},{"chi","ち"},{"chu","ちゅ"},{"che","ちぇ"},{"cho","ちょ"},
        {"cya","ちゃ"},{"cyi","ちぃ"},{"cyu","ちゅ"},{"cye","ちぇ"},{"cyo","ちょ"},
        {"fu","ふ"},
        {"ja","じゃ"},{"ji","じ"},{"ju","じゅ"},{"je","じぇ"},{"jo","じょ"},
        {"la","ぁ" },{"li","ぃ" },{"lu","ぅ" },{"le","ぇ" },{"lo","ぉ" },
        {"lya","ゃ" },{"lyu","ゅ" },{"lyo","ょ" },
        {"ltu", "っ"},
        {"nn","ん" },
        {"qu","く" },{"qyi","くぃ"},{"qye","くぇ"},
        {"sha","しゃ" },{"shi","し"},{"shu","しゅ"},{"she","しぇ"},{"sho","しょ"},
        {"tsu","つ"},
        {"yi","い"},{"ye","え"},
    };

    //渡した要素と紐づいている要素をdicから探し、リストにして返します。
    public KeyValuePair SearchdicKey(string key)
    {
        var dicpair = new KeyValuePair();

        foreach (KeyValuePair pair in dic)
        {
            if (key == pair.Key)
            {
                dicpair = pair;
            }
        }
        return dicpair;
    }

    //渡した要素と紐づいている要素をdicから探し、リストにして返します。
    public KeyValuePair SearchdicValue(string value)
    {
        var dicpair = new KeyValuePair();

        foreach (KeyValuePair pair in dic)
        {
            if (value == pair.Value)
            {
                dicpair = pair;
            }
        }
        return dicpair;
    }

     //渡した要素と紐づいている要素を両方のdicから探し、リストにして返します。
    public List> SearchTotaldicKey(string key)
    {
        var dicpair = new List>();

        foreach (KeyValuePair pair in Epicdic)
        {
            if (key == pair.Value)
            {
                dicpair.Add(new KeyValuePair(pair.Value, pair.Key));
            }
        }

        foreach (KeyValuePair pair in dic)
        {
            if (key == pair.Key)
            {
                dicpair.Add(pair);
            }
        }
        return dicpair;
    }

    //渡した要素と紐づいている要素を両方のdicから探し、リストにして返します。
    public List> SearchTotaldicValue(string value)
    {
        var dicpair = new List>();

        foreach (KeyValuePair pair in Epicdic)
        {
            if (value == pair.Value)
            {
                dicpair.Add(pair);
            }
        }

        foreach (KeyValuePair pair in dic)
        {
            if (value == pair.Key)
            {
                dicpair.Add(new KeyValuePair(pair.Value, pair.Key));
            }
        }
        return dicpair;
    }
}

SetList.cs

次にタイピングするKanjij.txtと同じ行にあるJapanese.txtとKanjiFuri.txtの文字列をSetLists()に渡し、それぞれを区分しながらListに要素を追加していきます。

・Japanese.txtは一度に入力可能でありながら、文字列が最長になるように区分し、FuriListに追加していきます。
・KanjiFuri.txtは1つの数字ごとに文字列を区分しながらKanjiFuriListに追加していきます。
・また、FuriListに要素を追加しながらDictionary.dicから入力方法を取得し、RomaListに追加していきます。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class SetList : MonoBehaviour
{
    private SetText ST;
    private Dictionary Dic;

    public List RomaList;
    public List FuriList;
    public List KanjiFuriList;

    void Awake()
    {
        ST = GetComponent();
        Dic = GetComponent();
    }

    private string FuriStr = "";
    private string RomaStr = "";

    //FuriStrとRomaStrの内容をそれぞれのリストに入れて初期化する。
    private void AddList()
    {
        FuriList.Add(FuriStr);
        RomaList.Add(RomaStr);

        FuriStr = "";
        RomaStr = "";
    }

    //渡されたJapanese.txtの一行を一文字づつ仕分けるよう
    public void SetLists(string Roma , string KanjiFuri)
    {

        for(int i = 0; i < Roma.Length - 1; i++)
        {
            var chr = Roma[i].ToString();

            switch (chr)
            {
                case "っ":

                    FuriStr += chr;

                    if (i != Roma.Length - 1)
                    {
                        switch(Roma[i + 1].ToString())
                        {
                            case "あ":
                            case "い":
                            case "う":
                            case "え":
                            case "お":
                            case "な":
                            case "に":
                            case "ぬ":
                            case "ね":
                            case "の":
                            case "ん":
                                RomaStr += Dic.SearchdicKey(Roma[i + 1].ToString()).Value;
                                AddList();
                                break;

                            default:
                                RomaStr += Dic.SearchdicKey(Roma[i + 1].ToString()).Value.Substring(0,1);
                                break;
                        }
                    }
                    else
                    {
                        FuriStr += chr;

                        AddList();
                    }
                    break;

                case "ぁ":
                case "ぃ":
                case "ぅ":
                case "ぇ":
                case "ぉ":
                case "ゃ":
                case "ゅ":
                case "ょ":

                    if (i != 0 && FuriStr != "")
                    {

                        if (Dic.dic.ContainsKey(FuriStr + chr))
                        {
                            FuriStr += chr;

                            RomaStr += Dic.SearchdicKey(Roma[i - 1].ToString() + chr).Value;

                            AddList();
                        }
                        else
                        {
                            AddList();
                            FuriStr += chr;
                            RomaStr += Dic.SearchdicKey(chr).Value;
                            AddList();
                        }
                    }
                    else
                    {
                        FuriStr += chr;

                        RomaStr += Dic.SearchdicKey(chr).Value;

                        AddList();
                    }

                    break;

                case "ん":

                    FuriStr += chr;
                    RomaStr += Dic.SearchdicKey(chr).Value;

                    if (i != Roma.Length - 1)
                    {
                        switch(Roma[i + 1].ToString())
                        {
                            case "あ":
                            case "い":
                            case "う":
                            case "え":
                            case "お":
                            case "な":
                            case "に":
                            case "ぬ":
                            case "ね":
                            case "の":
                            case "ん":
                            case "や":
                            case "ゆ":
                            case "よ":
                            case "ゃ":
                            case "ゅ":
                            case "ょ":
                                RomaStr += "n";
                                break;
                        }
                    }
                    else
                    {
                        RomaStr += "n";
                    }

                    AddList();

                    break;

                default:

                    if (i != Roma.Length - 1)
                    {
                        switch (Roma[i + 1].ToString())
                        {
                            case "ぁ":
                            case "ぃ":
                            case "ぅ":
                            case "ぇ":
                            case "ぉ":
                            case "ゃ":
                            case "ゅ":
                            case "ょ":

                                FuriStr += chr;

                                break;

                            default:
                                FuriStr += chr;
                                RomaStr += Dic.SearchdicKey(chr).Value;

                                AddList();
                                break;
                        }
                    }
                    else
                    {
                        FuriStr += chr;
                        RomaStr += Dic.SearchdicKey(chr).Value;

                        AddList();
                    }


                    break;
            }
        }

        int num = 0;

        for(int i = 0; i < KanjiFuri.Length - 1; i++)
        {
            num += KanjiFuri[i] - '0';

            KanjiFuriList.Add(num);
        }
    }
}

SetText.cs

txtファイルや表示中の文字列の行数、打ち終わった字数などを管理しています。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;


public class SetText : MonoBehaviour
{
    private SetList SL;
    private TypingSystem TS;

    [SerializeField] private TextAsset Furigana = null;     //ここにKanjiFuri.txtを入れる
    [SerializeField] private TextAsset Hiragana = null;     //ここにJapanese.txtを入れる
    [SerializeField] private TextAsset Kanji = null;        //ここにKanji.txtを入れる

    [SerializeField] private List FuriList = new List();
    [SerializeField] private List HiraList = new List();
    [SerializeField] private List KanjiList = new List();

    [SerializeField] private Text RomaText = null;  //ここにKanjiFuri.txtの内容を表示するためのテキストを入れる
    [SerializeField] private Text FuriText = null;  //ここにJapanese.txtの内容を表示するためのテキストを入れる
    [SerializeField] private Text KanjiText = null; //ここにKanji.txtの内容を表示するためのテキストを入れる

    [SerializeField] private int ColumunNum = -1; //現在打っている文字列の行数、最初に+1するため最初は-1にする

    private int SetColumunNum
    {
        get { return ColumunNum; }
        set
        {
            ColumunNum = value;
            SL.SetLists(HiraList[ColumunNum],FuriList[ColumunNum]);
            KanjiProp = 0;
            ListProp = 0;
            FuriProp = 0;
            RomaProp = 0;
        }
    }

    public int Romanum { get; private set; }
    public int Furinum { get; private set; }
    public int Kanjinum { get; private set; }
    public int Listnum { get; private set; }

    //メインの文字の設定
    private int KanjiProp
    {
        get { return Kanjinum; }
        set
        {
            Kanjinum = value;
            var kanjifuristr = "";
            kanjifuristr += KanjiList[ColumunNum].Insert(Kanjinum, "");
            KanjiText.text = kanjifuristr;
        }
    }

    //フリガナの文字の設定
    private int FuriProp
    {
        get { return Furinum; }

        set
        {
            Furinum = value;
            var furistr = "";
            furistr += HiraList[ColumunNum].Insert(Furinum, "");
            FuriText.text = furistr;

            while (Furinum >= SL.KanjiFuriList[Kanjinum])
            {
                KanjiProp++;
            }
        }
    }

    //SetList.FuriListの何個目の要素を打っているか
    private int ListProp
    {
        get { return Listnum; }

        set
        {
            if(value == SL.FuriList.Count)
            {
                ResetText();
                return;
            }
            else if(value != 0)
            {
                FuriProp += SL.FuriList[Listnum].Length;
            }
            Listnum = value;
        }
    }

    //ローマ字の設定
    public int RomaProp
    {
        get { return Romanum; }
        set
        {
            Romanum = value;

            if (Romanum == SL.RomaList[Listnum].Length)
            {
                ListProp++;
                TS.ResetTypedStr();
                RomaProp = 0;
            }
            else
            {
                var romastr = "";

                for (int i = 0; i < SL.RomaList.Count; i++)
                {
                    var str = SL.RomaList[i];

                    if (i != Listnum)
                    {
                        romastr += str;
                    }
                    else
                    {
                        romastr += str.Insert(Romanum, "");
                    }
                }
                RomaText.text = romastr;
            }
        }
    }

    private void Start()
    {
        SL = GetComponent();
        TS = GetComponent();

        SetStrList(Hiragana, HiraList);
        SetStrList(Furigana, FuriList);
        SetStrList(Kanji, KanjiList);

        ResetText();

        void SetStrList(TextAsset textAsset, List list)
        {
            var array = textAsset.text.Split('\n');
            list.AddRange(array);
        }
    }

    //テキストを初期化する
    private void ResetText()
    {
        SL.FuriList.Clear();
        SL.RomaList.Clear();
        SL.KanjiFuriList.Clear();

        SetColumunNum++;
    }

}

TypingSystem.cs

txtファイルや表示中の文字列の行数、打ち終わった字数などを管理しています。

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class TypingSystem : MonoBehaviour
{
    private SetList SL;
    private SetText ST;
    private Dictionary Dic;

    private string Typedstr;

    public void ResetTypedStr()
    {
        Typedstr = "";
    }

    private void Awake()
    {
        ST = GetComponent();
        SL = GetComponent();
        Dic = GetComponent();
    }

    string[] keys = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", 
        "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "-", ",",".","[","]"};

    //keys内にあるキーを打った時
    void Update()
    {
        foreach (string key in keys)
        {
            if (Input.GetKeyDown(key))
            {
                TypeJudge(key);
            }
        }
    }

    public void TypeJudge(string type)
    {
        //打っている途中の文字と現在打った文字をつなげる
        var JudgeStr = Typedstr + type;
        bool jud = false;

        //打った文字が n で 前の文字が nn じゃない場合
        if (type == "n" && SL.RomaList[ST.Listnum] == "n")
        {
            SL.RomaList[ST.Listnum] = "nn";
            RightEnter();
            return;
        }

        //正しく打てている場合
        if (type == SL.RomaList[ST.Listnum][ST.RomaProp].ToString())
        {
            RightEnter();
        }
        else
        {
            //Dictionaryの中のEpicDic内の文字を打とうとしている場合
            for (int i = SL.FuriList[ST.Listnum].Length; i != 0 && !jud ; i--)
            {
                var SearchStr = SL.FuriList[ST.Listnum].Substring(0,i);

                if (i != 1 && SL.FuriList[ST.Listnum][0].ToString() == "っ")
                {
                    SearchStr = SearchStr.Substring(1, SearchStr.Length-1);
                }

                var list = Dic.SearchTotaldicKey(SearchStr);

                foreach (var d in list)
                {
                    var MatchStr = "";

                    if (i != 1 && SL.FuriList[ST.Listnum][0].ToString() == "っ")
                    {
                        MatchStr += d.Value.Substring(0, 1);
                    }

                    if (JudgeStr.Length <= MatchStr.Length + d.Value.Length && !jud)
                    {

                        MatchStr += d.Value;

                        if (JudgeStr == MatchStr.Substring(0, JudgeStr.Length))
                        {
                            //print(MatchStr + "で見つかりました");
                            TypeMatch(i , MatchStr);
                        }
                    }
                }
            }

            //該当した文字が無い場合(ミスタイプしている場合)
            if(!jud)
            {
                MissEnter();
            }

        }

        //EpicDic内にある文字が正しく打てている時に呼び出される
        //打った文字とまだ打っていない文字を切り分ける作業をする
        void TypeMatch(int num, string MatchStr)
        {
            jud = true;
            var Furistr = SL.FuriList[ST.Listnum];
            SL.FuriList[ST.Listnum] = Furistr.Substring(0, num);
            SL.RomaList[ST.Listnum] = MatchStr;

            if(Furistr.Length != num)
            {
                SL.FuriList.Insert(ST.Listnum + 1, Furistr.Substring(num));
                SL.RomaList.Insert(ST.Listnum + 1, Dic.SearchdicKey(SL.FuriList[ST.Listnum + 1]).Value);
            }

            Typedstr = JudgeStr;
            RightEnter();
        }

        //ミスタイプしたとき
        void MissEnter()
        {
            print("ミスしました！");
        }

        //正しく打てているとき
        void RightEnter()
        {
            Typedstr = JudgeStr;
            ST.Romanum++;
        }
    }
}

実際に動かしてみる

上にあるプログラムを全て同じオブジェクトにアタッチし、以下の画像のように設定すると動きます。

完成した作品

そしてこのプログラムを組み込んで実際に完成した作品がこちらになります。

ケロツグ -雨乞いタイピング-

Webからのプレイはこちらから。
プロジェクトのダウンロードはこちらから

芥川龍之介の「蛙」の文をひたすら打つタイピングゲームです。
文字を打つたびに蛙が増えていき、正確なタイピングを続けると制限時間が増えたりします。

最後に

作るのは苦戦しましたが内容は結構シンプルな構造になっていると思います。
この方法で作っていると対応していないキーが出てくると思います。
見つけた場合はDisctionary.csの方に書き足して頂けると対応されると思います。

最後まで読んでいただきありがとうございました。

アニメーションについて1

2019-06-06T02:40:29+09:00

前置き

Unityを触る上でアニメーションはとても大事。らしい。
ま僕アニメーション部分担当した事ないですがw
なので先ずはアニメーションの基礎知識を学ぶのが必要らしいので↓のサンプルを元に勉強して行く。
(動作させた動画も撮ったけどどこにあげていいものかよく分からんので一旦保留。)

3DRunゲーム

(これ画像サイズ調節できる機能ないんか・・？）

障害物をぴょんぴょん乗り越えて行くオートスクロール系の3Drun。
これにはどんな技術が使われてるんだろうか。

Unityアニメーション基礎知識

Mecanim（メカニム）

・UnityにはMecanimと呼ばれるアニメーションシステムがある。
・Unity 4.0から導入されたアニメーションの機能。(ちなみに今はUnityの最新は2019)
・これ、スクリプト書かずにアニメーションが作れる（！？）らしい。

閑話

という事でMecanimを利用する事でプログラマーに頼らずアニメーション担当のスタッフだけでアニメーション部分の作成が可能なのだ！素晴らしい。分担って最高。

という事でアニメーションについてでは基本的にコードは書かず、
Unityの機能Mecanimと仲良くなって行こうと思います。
本格的にUnityのAnimetorコンポーネントとか触って行くのはまた次回。

Mecanimについての詳しい説明は参考サイトの方を見てください。ここに限らずググれば色々出てきます。多分触って覚えた方が分かりやすい感じですが。
ってあれ？この参考サイトにアニメーションの作り方書いてある？w

^o^・・・

ま、まぁ僕の方でもある程度掻い摘んで載せて行きます。
了

参考サイト

Mecanimについて

Unityでゲーム作る(方針のみ)

2019-06-05T02:03:50+09:00

Unityでゲーム作りたい

「ゲーム作るかー」と思ってても中々やらんし、ゲーム案件最近触ってないんで勉強がてらやっていきます。
先ずは記事だけ。明日から触って行く。
暇があったら別記事でhtml5ゲームの方も作ります。今はunity。

技術とか知見になる予定のもの

Unity
UniRx
2D/3D
AR/VR

閑話

俺の考えてるゲーム絶対面白いのに作る時間ないが？
作り方わからんが？

と多少プログラム触ってきたけど「おし、作るか！」から「はい完成！」とはいかないゲーム。
WebGL？iOS？Android？Steam？とかプラットフォーム選別から始めちゃうと「あ、だり」となってやらない事も多い。
「Unityのチュートリアル一通りやったぞwふんw」
って人には不要な記事かもしれない。

基本参考書の順番で作って行く。
2Dアクションゲームが本当は作りたいけど参考書の順番で作って行く。

参考書

Unityゲームプログラミング・バイブル