【UEFN】UIボタンの作り方を画像付きで徹底解説【Verse言語】

▼ 画面上部の「Verse」をクリックし、「Verseコードをビルド」を選択すればビルド完了です。

using { /Fortnite.com/Devices }
using { /Fortnite.com/UI }
using { /Verse.org/Simulation }
using { /Verse.org/Verse }
using { /UnrealEngine.com/Temporary/Diagnostics }
using { /UnrealEngine.com/Temporary/UI }
using { /UnrealEngine.com/Temporary/SpatialMath }

この部分は、使用するライブラリやデバイスを指定しています。

Fortnite.com、Verse.org、UnrealEngine.comの各ドメインからのデバイスやライブラリを利用しています。

# ボタンスタイルの選択肢を現在の3種類に固定します。: {button_loud = 1, button_quiet = 2, button_regular = 3}
buttonchoice_int := type{_X : int where 1 <= _X, 3 >= _X}

上記のコードは、buttonchoice_intという変数を定義しています。

これはボタンのスタイルを3つの選択肢（button_loud = 1、button_quiet = 2、button_regular = 3）に制限することを意味します。

menumanagerdevice := class(creative_device):

上記のコードは、menumanagerdeviceという名前のクラスを定義しています。

このクラスはcreative_deviceというクラスを継承しています。

    # The trigger that will open up this ui menu
    @editable TriggerToShowUI : trigger_device = trigger_device{}

上記のコードは、UIメニューを表示するためのトリガーを示しています。

TriggerToShowUIという名前の変数で、trigger_device型のオブジェクトとして設定されます。

このトリガーが発火するとUIメニューが表示されます。

    # An array of button ui, configurable via the editor
    @editable var ButtonUI : []buttonui = array{}

上記のコードは、ButtonUIという名前の変数を定義しています。

この変数はbuttonui型のオブジェクトの配列として設定されます。

この配列には複数のボタンUIが含まれます。エディタを介して設定可能です。

    var MaybeMyUIPerPlayer : [player]?canvas = map{}

上記のコードは、MaybeMyUIPerPlayerという名前の変数を定義しています。

この変数は、[player]に対応するキャンバス（UIの描画領域）のマップをオプション（存在しない場合もある）として設定します。

    StringToMessage<localizes>(String : string):message = "{String}"

上記のコードは、StringToMessageという関数を定義しています。

この関数はstring型の引数を取り、それをmessage型に変換して返します。

このコードは、ボタンのスタイルを3つの選択肢に制限するための変数と型の定義を行っています。

# Locks the choice of button styles to the current three: {button_loud = 1, button_quiet = 2, button_regular = 3}
buttonchoice_int := type{_X : int where 1 <= _X, 3 >= _X}

上記のコメント「#～」は、このコード行の目的を説明しています。

ボタンのスタイルを「button_loud = 1」「button_quiet = 2」「button_regular = 3」の3つに制限することを意味しています。

buttonchoice_intは変数の名前です。:=は変数に値を代入する演算子です。

type{_X : int where 1 <= _X, 3 >= _X}は、_Xという名前の整数型変数を持つ型を定義しています。

intは整数型を表し、whereキーワードを使って制約を設定します。

1 <= _X, 3 >= _Xは、_Xが1以上かつ3以下であることを制約しています。つまり、buttonchoice_intは1から3の値のみを取ることができるということです。

この定義により、buttonchoice_int変数はその範囲内の値しか受け付けず、ボタンスタイルの選択を1から3に制限することが保証されます。

例えば、以下のように使用できます：

button_choice: buttonchoice_int = 2

このように、button_choice変数に2を代入することはできますが、0や4を代入しようとするとエラーが発生します。

このように変数と型を組み合わせることで、プログラムの流れや意図を明確にし、不正な値の使用を防止することができます。

whereキーワードは、条件を指定するために使用されるプログラミングの構文要素です。指定した条件に合致するデータのみが該当の場所で使用されることができます。

具体的には、以下のような場面でwhereキーワードが使用されます。

• ジェネリック（汎用）型の制約：
  • 型パラメータに対して特定の条件を課すことができます。
  • 例えば、T where T: Numericというジェネリック型制約を使用すると、Tは数値型である必要があります。
• パターンマッチングでの条件指定：
  • 条件に合致するパターンのみが選択されるように指定することができます。
  • 例えば、match x where x > 5 => "Greater than 5" | x <= 5 => "Less than or equal to 5"というコードでは、xが5より大きい場合と5以下の場合で異なる処理を行います。
• 型の範囲指定：
  • 変数や型に制約を課すことができます。
  • 例えば、type{_X : int where 1 <= _X, _X <= 10}というコードでは、_Xが1から10の範囲に制約された整数型です。

whereキーワードを使うことで、プログラミングにおいて特定の条件に合致するデータやコードブロックを制御することができます。これにより、より具体的な要件を満たすデータや処理のみを扱うことができます。

button_loudクラスは、大きくて派手なスタイルが適用されたテキストボタンを表します。

以下のテクニカルな詳細を解説します。

継承階層:

• widget:
  • プレイヤーの画面上に描画されるすべてのUI要素の基底クラス
• text_button_base:
  • カスタムメッセージ文字列を表示するボタンの共通ベースクラス

データメンバ:

• DefaultText:
  • ユーザーに表示するテキスト。
  • ウィジェットの初期化時にのみ使用され、SetTextによって変更されません。

関数メンバ:

• GetParentWidget():
  • ウィジェットの親ウィジェットを取得します。
  • 親が存在しない場合（例：このウィジェットがplayer_uiになく、または自身がルートウィジェットである場合）は失敗します。
• GetRootWidget():
  • このウィジェットをplayer_uiに追加したウィジェットを取得します。
  • ルートウィジェットは自分自身を返します。
  • このウィジェットがplayer_uiにない場合は失敗します。
• GetText():
  • ウィジェットに現在表示されているテキストを取得します。
• GetVisibility():
  • 現在のウィジェットの表示状態（widget_visibility）を返します。
• IsEnabled():
  • プレーヤーによってインタラクティブに変更可能ならばtrueを返します。
• OnClick():
  • ボタンがクリックされたときに発生するサブスクライブ可能なイベントです。
• SetEnabled():
  • プレーヤーがこのウィジェットとのインタラクションを有効または無効にするかを設定します。
• SetText():
  • ウィジェットに表示されるテキストを設定します。
• SetVisibility():
  • 自身を含むplayer_uiから削除せずに、ウィジェットの表示または非表示を切り替えます。
  • 詳細はwidget_visibilityを参照してください。

これらのメンバや関数を使用することで、button_loudクラスのインスタンスを作成し、テキストボタンの動作や表示をカスタマイズすることができます。

たとえば、SetText()メソッドを使ってボタンのテキストを設定し、OnClick()イベントを購読してボタンがクリックされたときの処理を追加することができます。

『type macro』とは、式の型を取得するためのマクロ（あるいは機能）です。

型が使われるどんな場所でも使用できるのが特徴的。

例えば以下のとおり。

Foo() : int = 0
Bar(X : type{Foo()}) : type{Foo()} = X

この例では、関数Fooの型を取得してtype{Foo()}として使用しています。

typeマクロは、特に関数の型を記述するために便利です。

また、デフォルトでない影響を持つ別の関数の戻り値の型を指定するためにも使用する必要があります。

comparison := enum:
    LT
    EQ
    GT

Less(X : int, Y : int)<decides> : int =
    X < Y

Equal(X : t, Y:comparable where t:subtype(comparable))<decides> : t =
    X = Y

Greater(X : int, Y : int)<decides> : int =
    X > Y

Comparison(Arg : comparison) : type{_(:int, :int)<decides> : int} =
    case (Arg):
        comparison.LT => Less
        comparison.EQ => Equal
        comparison.GT => Greater

この部分では、comparison関数がcomparison列挙型を、各異なる列挙値に対応する比較操作に変換します。

この例では、特別な _ 識別子も使用しています。

この識別子は、名前を提供する必要がないがそれ以外で使用されない場所で識別子が期待される場所で使用することができます。

【例】

例えを挙げるとするならば、ある料理のレシピを考えてみることができます。

レシピ（関数）には、特定の材料の種類（型）が必要です。

その材料を利用するための手順（式）を記述し、特定の種類のレシピ（関数）を呼び出すことで、目的の料理（結果）を作り出すことができます。

Type Macroは、式の型を取得するためのマクロ（もしくは機能）なわけですね。

あすか

# ボタンスタイルの選択肢を現在の3種類に固定します。: {button_loud = 1, button_quiet = 2, button_regular = 3}
buttonchoice_int := type{_X : int where 1 <= _X, 3 >= _X}

このコードは、ボタンのスタイルを表す選択肢を、現在の3種類に固定するためのものです。

• 1行目のコメント # ボタンスタイルの選択肢を現在の3種類に固定します。 は、プログラムの目的を説明しています。
• 2行目の buttonchoice_int := は、buttonchoice_int という新しい型を定義することを示しています。
• := は、右辺の値を左辺の識別子（この場合は buttonchoice_int）に割り当てる演算子です。
• 3行目の type{_X : int where 1 <= _X, 3 >= _X} は、型の定義を行っています。
  • type{...} は、新しい型を定義するための構文です。
    • この場合、_X という型パラメータ（ジェネリック）を持つ型を定義しています。
  • _X : int は、型パラメータ _X の型が整数型（int）であることを意味しています。
  • where キーワード：以下の制約は、型パラメータに対して課される条件を示しています。
    • 1 <= _X は、型パラメータ _X の値が1以上であることを要求しています。
    • 3 >= _X は、型パラメータ _X の値が3以下であることを要求しています。

これにより、buttonchoice_int 型は、整数型の値であってかつ1から3の範囲内にある値を持つことが保証されます。

この制約を使用することで、特定の範囲内の値のみを受け入れることができ、プログラムの正確性を向上させることができます。

あすか

# ボタンスタイルの選択肢を現在の3種類に固定します。: {button_loud = 1, button_quiet = 2, button_regular = 3}
buttonchoice_int := type{_X : int where 1 <= _X, 3 >= _X}

{}（中括弧）は、型を囲んで定義するために使用されます。これは、特定の制約や要件を持つ新しい型を作成するための構文です。

中括弧内には、型の定義や制約を記述することができます。

このような構文を使うことで、独自の型を作成し、その型に特定の条件を課すことができます。

type{...} の構文を使って型を定義するメリットは以下のとおり。

1. 制約の表現:
   • {} 内に書かれた条件や制約は、型や値に対して特定の要件や制限を表現するために使用されます。
   • 例えば、整数型であることや範囲の制約などを指定することが可能です。
2. 型パラメータの使用:
   • {} 内に型パラメータ（ジェネリック）を定義することができます。
   • 型パラメータは、汎用的な型を定義する際に使用され、実際の型が具体的に与えられるまでは抽象的なままとなります。
3. 新しい型の作成:
   • {} を使用することで、既存の型から派生した新しい型を作成することができます。
   • 「型拡張」といった概念に近いものです。特定の型に制約を加えることで、より具体的な意味を持つ新しい型を定義することができます。

プログラミングにおいて、型はコードの読みやすさやメンテナンス性に大きく貢献します。命名された型を使用することで、コードの意図が明確になったり、エラーをコンパイル時に捕捉することができるようになります。

{} で囲まれた型定義は、そのような利点を活かすための一つの方法です。

# ボタンスタイルの選択肢を現在の3種類に固定します。: {button_loud = 1, button_quiet = 2, button_regular = 3}
buttonchoice_int := type{_X : int where 1 <= _X, 3 >= _X}

"_X : int"という記述は、型制約（type constraint）または型の範囲を指定するものです。ここでは、"_X"という名前の整数型を表現しています。

制約 "1 <= _X, 3 >= _X"は、"_X"の値が1以上かつ3以下であることを要求しています。

つまり、buttonchoice_int型の値は1、2、または3のみを取り得るわけですね。

りゅう

_X : int"という記述は、範囲（1から3までの整数）を指定するために使用されるんですね！

このコードは、 menumanagerdevice というクラス（class）を定義しています。

クラスは、オブジェクト指向プログラミングの概念の1つであり、関連する変数（属性）や関数（メソッド）をグループ化して、再利用可能なコードの単位となります。

そのクラスは creative_device クラスを継承しています（class(creative_device)）。

クラスの継承は、既存のクラス（親クラスやスーパークラスと呼ばれる）の機能を引き継ぐことができる仕組みです。継承により、menumanagerdevice クラスは creative_device クラスの属性やメソッドを利用できるようになります。

【例】

例えば、親クラスを「車」、子クラスを「スポーツカー」とします。

車には共通の特徴や機能がありますが、スポーツカーはさらに特化した機能を持っています。

class Car:
    def __init__(self, brand, color):
        self.brand = brand
        self.color = color

    def start_engine(self):
        print(f"The {self.brand} car's engine starts.")

class SportsCar(Car):
    def __init__(self, brand, color, top_speed):
        super().__init__(brand, color)
        self.top_speed = top_speed

    def race(self):
        print(f"The {self.color} {self.brand} sports car is racing at {self.top_speed} mph!")

この例では、Car クラスが親クラス（またはスーパークラス）であり、SportsCar クラスが子クラス（またはサブクラス）です。

SportsCar クラスは Car クラスを継承しているため、Car クラスが持つ属性やメソッドを利用できます。

車（Car クラス）にはブランドと色の属性があり、エンジンを始動する機能（start_engine メソッド）があります。

スポーツカー（SportsCar クラス）はさらに、最高速度（top_speed 属性）やレースする機能（race メソッド）を持っています。

実際にインスタンスを作成して使ってみましょう。

car = Car("Toyota", "Blue")
car.start_engine()  # "The Toyota car's engine starts." と出力

sports_car = SportsCar("Ferrari", "Red", 200)
sports_car.start_engine()  # "The Ferrari car's engine starts." と出力
sports_car.race()          # "The Red Ferrari sports car is racing at 200 mph!" と出力

親クラスの Car クラスを継承した子クラスの SportsCar クラスでは、親クラスの属性（brand、color）やメソッド（start_engine）を利用しています。

また、子クラスには独自の属性（top_speed）やメソッド（race）が追加されています。

他にも、「鳴く」という親クラスを継承して、子クラスで「にゃー」「わんっ！」などに変更することもできます😌

あすか

みなみ

継承を使うことで親クラスのメソッドを子クラスでカスタマイズできるわけですね🌸

このコードは、UIメニューを開くためのトリガーを定義するためのものです。

# UIメニューを開くトリガー
@editable
TriggerToShowUI: trigger_device = trigger_device{}

1行目: # はコメントを表す記号です。プログラムの解説やメモなどを書くために使われます。

2行目: @editable はデコレーター（Decorator）と呼ばれるもので、いわゆる修飾子です。コードの一部や関数に修飾を加え、特定の振る舞いをさせる役割があります。

3行目: TriggerToShowUI: trigger_device = trigger_device{} は変数やデータの定義です。

• TriggerToShowUI はこの変数の名前です。
  • 変数名は自由につけることができますが、意味のある名前をつけることが推奨されます。
• trigger_device は変数の型（type）やクラス（class）を示しています。
  • 具体的な型やクラスの定義はこのコード部分には示されていません。
• = は代入演算子で、右辺の値を左辺の変数に代入する役割があります。
• trigger_device{} は右辺の値で、trigger_device という変数の初期値を示しています。
  • ここでは空の辞書（dictionary）を初期値として設定しています。

# エディターで設定可能なボタンUIの配列
@editable
var ButtonUI : []buttonui = array{}

この部分は、エディターで設定可能なボタンUIの配列を定義しています。

具体的には以下のとおり。

• # はコメントを表す記号です。この行は説明コメントとして使われています。
• @editable はデコレーター（Decorator）と呼ばれるもので、エディター上でこの変数を編集できるようにするための指示です。
• var は変数（variable）の宣言を表します。
• ButtonUI は変数の名前で、エディターで設定可能なボタンUIの配列を表しています。
  • 変数名は自由につけることができますが、意味のある名前を付けることが推奨されます。
• : []buttonui は変数の型（type）を意味します。
  • buttonui は、この変数が要素として持つことができるデータ型を示しています。
  • また、[] は配列（array）を表し、複数の要素を持つことができます。
• = array{} は変数の初期値を示しています。
  • array{} は空の配列を初期値として設定しています。
  • つまり、最初はボタンUIの配列は空です。

この部分の目的は、エディター上で設定可能なボタンUIの配列を表現し、プログラムの他の部分で使用するために宣言していることです。

エディター上でこの配列を編集できるようにするために、@editable デコレーターが使われています。

1. var MaybeMyUIPerPlayer:

• var は変数（variable）の宣言を表します。
• MaybeMyUIPerPlayer は変数の名前です。

2. : [player]?canvas:

• : は型指定子で、「この変数の型は以下のようになります」という意味です。
• [player]?canvas は、player 型のキーと canvas 型の値を持つ辞書（ディクショナリ）を表します。
  • [player] はキーの型を player とし、辞書のキーとして利用します。
  • ?canvas は値の型を canvas とし、それが null（値が存在しない）かもしれないことを示します。

3. = map{}:

• = は代入演算子で、右辺の値を左辺の変数に代入します。
• map{} は空の辞書を表し、MaybeMyUIPerPlayer に初期値として設定されます。

つまり、このコードは、プレイヤーごとにカスタムのUIを保持するための変数 MaybeMyUIPerPlayer を作成し、それぞれのプレイヤーに対して canvas 型のUIを関連付ける辞書を初期化しています。

ただし、プレイヤーのキーに対応するUIが存在しない場合、その値は null となる可能性があることを示しています。

例えば、MaybeMyUIPerPlayer の中身を具体的に表すと以下のようなイメージです（仮に2人のプレイヤーデータがある場合）：

{
  Player1: canvas1,  // プレイヤー1のUIはcanvas1
  Player2: null,    // プレイヤー2のUIはまだ設定されていない（null）
}

このように、変数 MaybeMyUIPerPlayer を使用することで、各プレイヤーごとに異なるUIを保持できるデータ構造を作成することができます。

Mapとは、他の値と関連付けられた値の組み合わせ（キーと値のペア）を格納するコンテナです。ユニークなキーを使用して要素にアクセスすることができます。

例えば、単語の出現回数をカウントするために、単語をキーとして、その出現回数を値として持つマップを作成することができます。

WordCount : [string]int = map{"apple" => 11, "pear" => 7}

もし同じキーを複数回使用した場合、マップはそのキーに対して最後に提供された値のみ保持します。

次の例では、WordCountは "apple" => 2 のキーと値のペアのみを保持します。"apple" => 0 や "apple" => 1 のペアは破棄されます。

WordCount : [string]int = map{"apple" => 0, "apple" => 1, "apple" => 2}

サポートされるキーの型は、キーの存在をチェックする方法が必要なので、比較可能（comparable）な型である必要があります。

以下のタイプはキーとして使用できます：

• 論理値（logic）
• 整数（int）
• 浮動小数点数（float）
• 文字（char）
• 文字列（string）
• 列挙型（enum）
• 比較可能な場合、クラス（class）
• 要素の型が比較可能な場合、オプション（option）
• 要素の型が比較可能な場合、配列（array）
• キーと値の型が比較可能な場合、マップ（map）
• 全ての要素が比較可能な場合、タプル（tuple）

マップの要素数は、フィールドLengthにアクセスすることで取得することができます。例えば、map{"a" => "apple", "b" => "bear", "c" => "candy"}.Lengthは 3 を返します。

マップ内の要素にアクセスするためには、キーを使用します。

例えば、WordCount["apple"] とすることでマップ内の要素にアクセスできます。

マップ内の要素へのアクセスは、失敗時のコンテキスト（if文など）でのみ使用できるエラーが発生しうる表現です。

要素をマップに追加するには、特定のキーに値を設定することで行います。

例えば、ExampleMap["d"] = 4 とすることで要素を追加できます。既存のキーと値のペアは、既にマップ内に存在するキーに値を再設定することで更新することができます。

マップから要素を削除するには、削除したいキーを除いた新しいマップを作成します。

【例】

電話帳は、人々の名前（キー）と電話番号（値）のペアを格納しています。電話帳内の名前を使って、対応する電話番号にアクセスすることができます。

例えば、マップの場合：

PhoneBook : map{
  "Alice" => "123-456-7890",
  "Bob" => "987-654-3210",
  "Charlie" => "555-123-4567"
}

電話帳の中から「Bob」の電話番号を調べたい場合、PhoneBook["Bob"]とすることで対応する電話番号にアクセスできます。

また、新しい連絡先を追加する場合、電話帳に新しい名前と電話番号のペアを追加します。例えば、PhoneBook["Dave"] = "777-888-9999"とすることで「Dave」の情報を追加できます。

逆に、誰かが電話帳から削除された場合は、その名前のエントリを電話帳から削除します。

マップは、様々なデータの関連を保存するときに便利で、キーを使って素早く値にアクセスすることができるわけです。

あすか

Comparable（コンペアラブル）は、値を比較するための要件を追加するために使用される型です。つまり、Comparable型の値は、その型の他の値と比較可能であることが要求されます。

例えば、int型はComparableのサブタイプです。これは、整数同士を比較できるということです。つまり、2と3を比較したり、5と8を比較したりすることができます。

Comparableでは、=（等号）と<>（不等号）の演算子が利用できます。これらの演算子を使用して、同じ型の値同士を比較するためのシグネチャ（関数の定義）を定義します。

以下は、=と<>の演算子のシグネチャ例です：

operator '=' (a: T, b: T) -> bool where T : subtype(Comparable) # 同じ型の値を比較して真偽値を返す
operator '<>' (a: T, b: T) -> bool where T : subtype(Comparable) # 同じ型の値を比較して真偽値を返す

これらの関数は、Comparableの任意のサブタイプを持つ第一引数と第二引数を受け取り、同じ型を返します。

Comparable型にはさまざまなサブタイプがあります。

具体的には以下のとおり。

• int: 整数を比較する
• logic: 真偽値を比較する
• float: 浮動小数点数を比較する
• char: 文字を比較する
• char32: Unicode文字を比較する
• 配列: すべての要素がComparableのサブタイプである場合、配列を比較する
• オプション: 内部の型がComparableのサブタイプである場合、オプション型を比較する
• タプル: 含まれるすべての型がComparableのサブタイプである場合、タプルを比較する
• マップ: 含まれるすべての型がComparableのサブタイプである場合、マップを比較する

ただし、現在のところ、float、option、およびandのクラスはマップのキーとして使用できません。マップのキーの型は、Comparableのサブタイプである必要があります。

注意点として、Comparableの異なるサブタイプの値を比較する場合、予期しない結果が生じる可能性があることに注意してください。例えば、0（整数）と0.0（浮動小数点数）の比較は失敗します。

なぜなら、intとfloatはサブタイプ関係を共有していないからです。

Verseでは「0」と「0.0」は別物として認識すると把握しておけばOKです。

あすか

サブタイプとは、ある型が別の型のサブセットとして振る舞うことを意味します。具体的には、ある型の値が別の型の変数や式で利用できる場合、その型はサブタイプです。

例えば、Square（正方形）とRectangle（長方形）という2つのクラスがあるとします。RectangleはSquareの一般化されたバージョンとして考えることができます。

この場合、SquareはRectangleのサブタイプです。なぜなら、SquareのインスタンスはRectangle型の変数や式で利用できるからです。つまり、SquareはRectangleとして振る舞うことができます。

サブタイプは、ポリモーフィズムや継承の機能を実現する上で重要です。プログラム内の異なる型の値を同じく扱えるようにすることで、柔軟性や再利用性を高めることができます。

ただし、サブタイプ関係は注意深く設計する必要があり、型の不変条件や機能の適切な制約を守ることが重要です。

【例】

例えば、果物を考えてみましょう。果物には多くの種類がありますが、共通の特徴や属性があります。これらの共通点に基づいて、果物を表現するための「Fruit（果物）」という基底クラスを作成します。

この「Fruit」クラスには、果物に共通の属性やメソッドが含まれます。

例えば、「形状（shape）」、「色（color）」、「味（taste）」などです。

さて、具体的な果物の種類として、「Apple（りんご）」クラスと「Banana（ばなな）」クラスを考えてみましょう。

「Apple」クラスと「Banana」クラスはどちらも「Fruit」クラスを継承します。つまり、「Apple」や「Banana」は「Fruit」のサブタイプです。

「Apple」クラスや「Banana」クラスは、それぞれの特有の属性やメソッドを持ちます。

例えば、「Apple」クラスには「種類（variety）」や「産地（origin）」が含まれるかもしれません。

一方、「Banana」クラスには「長さ（length）」や「曲がり具合（curvature）」が含まれるかもしれません。

これらのクラスのインスタンスは、果物としての共通の要素や操作を持つため、果物の変数や関数で利用することができます。例えば、果物のリストを扱う関数に「Apple」や「Banana」のインスタンスを渡すことができます。

このように、果物の階層構造において、「Fruit」が基底クラスであり、「Apple」と「Banana」がサブクラス（サブタイプ）となることで、共通の特性を共有しながらそれぞれの独自の特性を持つことができるのです。

サブクラスはしばしば「子クラス」（subclass）とも呼ばれます。サブクラス（子クラス）という用語は、オブジェクト指向プログラミングにおける継承関係を反映した用語です。

クラス継承では、あるクラス（親クラスまたは基底クラス）を別のクラス（子クラスまたは派生クラス）が継承することで、親クラスの属性やメソッドを使いまわしたり、派生クラスに独自の属性やメソッドを追加することができます。

この継承関係の中で、親クラスが子クラスよりも広範な概念を表現するとき、親クラスは「スーパークラス」とも呼ばれます。一方、子クラスは、親クラスを特化させたり、追加の機能を持たせたりするために使用されます。

サブクラス（子クラス）は、親クラス（基底クラス）の特性を受け継ぎながら、独自の機能や特性を追加することができます。

あすか

canvasをオプション（Option）(?)にすることで、MaybeMyUIPerPlayerの要素が存在する場合と存在しない場合の両方を処理できるようにしています。オプション型は、値が存在するかどうか不確定な場合に使用されます。

このコードでは、MaybeMyUIPerPlayerは[player]をキーとしてcanvasを値とする辞書です。

[player]キーに対応するcanvasが存在しない場合、その要素はnilまたはnullとなります。

オプション型を使用することで、辞書内に特定のプレイヤーに関連付けられたcanvasがまだ存在しない場合も適切に扱えます。

オプション型を活用することで、プログラムの柔軟性やエラーハンドリングが向上し、予期しない状況に対応することができます。

MaybeMyUIPerPlayerの型を [player]?canvas としてオプション (?) にしている理由は、以下のような場合に役立つためです。

1. プレイヤーがUIを持っていない場合：
   • もしプレイヤーがまだUIを作成していない場合、MaybeMyUIPerPlayer[Player] は null もしくは undefined となります。
   • これにより、UIが存在しないプレイヤーの特定や操作を容易にすることができます。
2. UIを削除する場合：
   • プレイヤーがUIを削除した場合、MaybeMyUIPerPlayer[Player] を null もしくは undefined に設定することで、UIが削除された状態を示すことができます。

逆に、オプション (?) を使わない場合、MaybeMyUIPerPlayer の型は map[player, canvas] となります。

これは必ずプレイヤーごとにUIが存在することを意味します。そのため、UIを持たないプレイヤーを表現するために特別な値（例：null）を使用しなければなりません。

値の追跡や操作が煩雑になり、プレイヤーがUIを持っていないことを明示的に示す必要があります。

オプションを使用することで、MaybeMyUIPerPlayer の状態をより明確に表現できるため、プレイヤーごとのUIの管理と追跡がより柔軟かつ簡潔になります。

あすか

みなみ

プレイヤーがいないのに「存在する」と判定されるのはエラーの原因になりますもんね🌸

buttonuiとは、Fortniteクリエイティブデバイスで使用されるボタンのユーザーインターフェース（UI）を表すクラスです。

以下に、buttonuiクラスの要素とその機能を解説します。

• ButtonText（ボタンのテキスト）:
  • ボタンに表示されるテキストを指定するためのプロパティです。
  • 例えば、"Play"や"Cancel"などのテキストを設定することができます。
• ButtonPosition（ボタンの位置）:
  • ボタンの表示位置を指定するためのプロパティです。
  • 2Dベクトルを使用して、ボタンのX座標とY座標を指定します。
• ButtonSize（ボタンのサイズ）:
  • ボタンの表示サイズを指定するためのプロパティです。
  • 2Dベクトルを使用して、ボタンの幅（X）と高さ（Y）を指定します。
• ButtonStyle（ボタンのスタイル）:
  • ボタンの見た目や振る舞いを指定するためのプロパティです。
  • 事前に定義された3つのスタイル（button_loud、button_quiet、button_regular）のいずれかを選択します。
• RemovesUIOnClick（クリック時にUIを削除するかどうか）:
  • ボタンをクリックした時に、関連するUIを自動的に削除するかどうかを指定するプロパティです。
  • trueに設定すると、ボタンクリック時にUIが非表示になります。
• SaveButtonState（ボタンの状態を保持するかどうか）:
  • ボタンの状態をUIを終了しても保持するかどうかを指定するプロパティです。
  • 例えば、ボタンが非表示になっている場合でも、UIを再度開いた際にその状態を維持するかどうかを設定できます。
• ButtonSignal_Recieve（ボタンの受信信号処理）:
  • ボタンがクリックされたときの処理を指定するためのプロパティです。
  • ButtonUI_UserOptions_Functionsという別のクラスのインスタンスを指定することで、ボタンクリック時の動作をカスタマイズできます。
• ButtonSignal_Send（ボタンの送信信号処理）:
  • ボタンがクリックされたことを他の部分に通知するためのプロパティです。
  • ButtonUI_UserOptions_Eventsという別のクラスのインスタンスを指定することで、ボタンクリックのイベントを送信できます。
• SizeToContent（コンテンツに合わせたサイズ）:
  • ボタンのサイズを内部のコンテンツに合わせるかどうかを指定するプロパティです。
  • trueに設定すると、ボタンのサイズが自動的に変更されます。
• ButtonWidgetPerPlayer（プレイヤーごとのボタンウィジェット）:
  • 各プレイヤーに対する個別のボタンウィジェットを保持するための辞書です。
  • プレイヤーをキーとして、ウィジェットの値を取得したり設定したりできます。
• EnabledStateMap（ボタンの有効状態を保持する辞書）:
  • 各プレイヤーに対するボタンの有効状態（enabled/disabled）を保持するための辞書です。
  • プレイヤーをキーとして、有効状態の値を取得したり設定したりできます。
• VisibleStateMap（ボタンの表示状態を保持する辞書）:
  • 各プレイヤーに対するボタンの表示状態（visible/hidden）を保持するための辞書です。
  • プレイヤーをキーとして、表示状態の値を取得したり設定したりできます。
• EnableWidget（ウィジェットの有効化）:
  • 指定したプレイヤーに対するボタンウィジェットを有効にするメソッドです。
• DisableWidget（ウィジェットの無効化）:
  • 指定したプレイヤーに対するボタンウィジェットを無効にするメソッドです。
• (Agent : agent).SaveEnabledState（有効状態の保存）:
  • ボタンの有効状態を指定したプレイヤーごとに保存するメソッドです。
• ShowWidget（ウィジェットの表示）:
  • 指定したプレイヤーに対するボタンウィジェットを表示するメソッドです。
• HideWidget（ウィジェットの非表示）:
  • 指定したプレイヤーに対するボタンウィジェットを非表示にするメソッドです。
• (Agent : agent).SaveVisibleState（表示状態の保存）:
  • ボタンの表示状態を指定したプレイヤーごとに保存するメソッドです。

buttonuiクラスは、ボタンのUIを定義し、ボタンの見た目や動作をカスタマイズするための多くのプロパティとメソッドを提供します。

これらの機能を使用することで、Fortniteクリエイティブデバイスで個別のボタンの振る舞いを実現することができます。

あすか

buttonuiは、Fortnite（フォートナイト）ゲーム内でUI（ユーザーインターフェース）の中に表示されるボタンを表現するためのオブジェクトです。

このコードは、Fortnite内のゲームメニューで使用されるボタンUIの動作を制御するためのクラスです。

buttonui := class<concrete>():

この行はbuttonuiクラスの定義を始めることを示します。

@editable 
var ButtonText : string = ""
@editable 
var ButtonPosition : vector2 = vector2{}
@editable 
var ButtonSize : vector2 = vector2{X := 475.0, Y:= 80.0}

上記の行では、ボタンのテキスト（ButtonText）、位置（ButtonPosition）、サイズ（ButtonSize）を定義しています。

@editableは、これらのプロパティがエディター上で編集可能であることを示します。

例えば、ButtonTextを"Play"に設定すると、ボタンには"Play"というテキストが表示されます。

@editable 
var ButtonStyle : buttonchoice_int = 3

ここでは、ボタンのスタイル（ButtonStyle）をbuttonchoice_intという特別なデータ型で定義しています。

このデータ型は、1から3までの整数しか受け付けないように設定されています。

これにより、ボタンのスタイルを3つの選択肢の中から選ぶことができます。

あすか

@editable 
var RemovesUIOnClick : logic = true

RemovesUIOnClickは、ボタンがクリックされた後にUI（メニュー）を非表示にするかどうかを制御します。

logicは論理値（真または偽）を表すデータ型で、trueの場合はボタンがクリックされた後にUIが非表示になります。

@editable 
SaveButtonState : logic = false

SaveButtonStateは、ボタンの状態を記憶しておくかどうかを制御します。

例えば、ボタンを非表示にしてメニューを閉じ、再度メニューを開いた際に、前回非表示にしたボタンが引き続き非表示の状態で表示されるかどうかを指定します。

@editable 
ButtonSignal_Recieve : ButtonUI_UserOptions_Functions = ButtonUI_UserOptions_Functions{}
@editable 
ButtonSignal_Send : ButtonUI_UserOptions_Events = ButtonUI_UserOptions_Events{}

ButtonSignal_RecieveとButtonSignal_Sendは、ボタンがクリックされた際の振る舞いを定義する関数やイベントを指定するためのプロパティです。

詳細な振る舞いは、ButtonUI_UserOptions_FunctionsやButtonUI_UserOptions_Eventsという別のオブジェクトで定義されています。

var SizeToContent : logic = false

SizeToContentは、ボタンのサイズを内容に合わせて自動調整するかどうかを制御します。

trueの場合、ボタンのサイズはテキストの内容に応じて自動的に変更されます。

var ButtonWidgetPerPlayer : [agent]widget = map{}

ButtonWidgetPerPlayerは、各プレイヤーごとにボタンのウィジェット（ゲーム内の要素）を記憶するためのマップです。

各プレイヤーに対して、対応するウィジェットが格納されます。

var EnabledStateMap : [agent]logic = map{}
var VisibleStateMap : [agent]logic = map{}

EnabledStateMapとVisibleStateMapは、ボタンの有効・無効状態や表示・非表示状態をプレイヤーごとに記憶するためのマップです。

各プレイヤーに対して、対応する状態が格納されます。

EnableWidget(Agent : ?agent):void=

EnableWidgetは、指定されたプレイヤーのボタンを有効にするための関数です。

指定されたプレイヤーが存在し、対応するウィジェットがあれば、それを有効にします。

DisableWidget(Agent : ?agent):void=

DisableWidgetは、指定されたプレイヤーのボタンを無効にするための関数です。

指定されたプレイヤーが存在し、対応するウィジェットがあれば、それを無効にします。

(Agent : agent).SaveEnabledState(State : logic):void=

SaveEnabledStateは、指定されたプレイヤーのボタンの有効・無効状態を保存するための関数です。

プレイヤーごとに、有効・無効の状態が記憶されます。

ShowWidget(Agent : ?agent):void=

ShowWidgetは、指定されたプレイヤーのボタンを表示するための関数です。

指定されたプレイヤーが存在し、対応するウィジェットがあれば、それを表示します。

HideWidget(Agent : ?agent):void=

HideWidgetは、指定されたプレイヤーのボタンを非表示にするための関数です。

指定されたプレイヤーが存在し、対応するウィジェットがあれば、それを非表示にします。

(Agent : agent).SaveVisibleState(State : logic):void=

SaveVisibleStateは、指定されたプレイヤーのボタンの表示・非表示状態を保存するための関数です。プレイヤーごとに、表示・非表示の状態が記憶されます。

配列を使用する理由は以下のとおりです。

1. 複数のボタンUIを管理するため:
   • 配列は、同じ型の要素を複数保持できるデータ構造です。
   • ボタンUIを配列として定義することで、複数のボタンUIを一つの変数で管理できます。
   • これにより、複数のボタンUIに対して一括で処理を行ったり、ループを使用して同じ処理を繰り返したりすることが容易になります。
2. ダイナミックな追加・削除:
   • 配列は要素の追加や削除が容易です。
   • 新しいボタンUIが必要になったり、ボタンUIを削除したりする場合に便利です。
   • 要素の追加や削除は配列の操作として行えるため、プログラムの柔軟性や拡張性が向上します。
3. インデックスによるアクセス:
   • 配列は各要素にユニークなインデックスを持っています。
   • 配列の要素には、その位置を指定するインデックス番号が割り当てられます。
   • これにより、ボタンUIを特定の順序で参照したり、特定のボタンUIを直接アクセスしたりすることができます。

例えば、上記のコードではButtonUIという名前の配列が定義されており、複数のbuttonuiオブジェクトを保持しています。この配列を使うことで、異なるボタンUIを同じ変数名で管理することができます。

新しいボタンUIが追加された場合、ButtonUI配列に要素を追加して管理することができます。

また、ループを使用することで、配列内のボタンUIに対して一括で処理を行うことができます。

例えば、全てのボタンUIを無効化するためには、ButtonUI配列内の要素を順番に取り出し、DisableWidget関数を呼び出すことができます。

配列を使用することで、管理や処理の効率化が図られ、柔軟性の高いプログラムを実現することができます。

あすか

    # エディタで設定可能なボタンUIの配列
    @editable var ButtonUI : []buttonui = array{}

    # プレーヤーごとに、キャンバスが存在するかどうかを保持する辞書型の変数。
    var MaybeMyUIPerPlayer : [player]?canvas = map{}

上記のコードにおいて、「var」キーワードが使用されているのは、次の場所での変数宣言です。

1. var ButtonUI : []buttonui = array{}:
   • この行では、ButtonUIという変数が[]buttonuiという型で宣言されています。
   • また、初期値としてarray{}が設定されています。
   • varキーワードを使用することで、この変数には後で別の値を代入することが可能になります。
   • つまり、後でButtonUIに新しい配列を代入することができます。
2. var MaybeMyUIPerPlayer : [player]?canvas = map{}:
   • この行では、MaybeMyUIPerPlayerという変数が[player]?canvasという型で宣言されています。
   • また、初期値としてmap{}が設定されています。
   • [player]?canvasは、playerごとに存在するかどうかが保持される辞書型の変数を表しています。
   • 同様に、varキーワードを使用することで、この変数には後で別の値を代入することが可能になります。

varキーワードによって変数が宣言された場合、その変数は後で別の値を代入することができます。

このコードでは、特にButtonUIとMaybeMyUIPerPlayerという変数が後で値を変更される可能性があるため、「var」キーワードを使用していますね。

あすか

具体例を挙げると、「ButtonUI」と「MaybeMyUIPerPlayer」変数が値が変更される可能性がある場面は以下のような場合です。

1. 「ButtonUI」変数が値が変更される可能性の例:
   • ユーザーが実行時にUI上でボタンを追加する場合や、既存のボタンを削除する場合に、ボタンの情報を更新する必要が生じます。
   • その際に、この変数に新しい配列を代入してボタンの変更を反映することがあります。
   • 例えば、ボタンの追加や削除がUIイベントやボタンの状態に応じて行われる場合には、ButtonUIの値が変更される可能性があります。
2. 「MaybeMyUIPerPlayer」変数が値が変更される可能性の例:
   • プレーヤーごとにキャンバスの存在を保持する辞書型の変数ですので、プレーヤーが新しく参加したり離脱したりする場合に、その情報を反映するために値が変更されることがあります。
   • 例えば、新しいプレーヤーが参加した場合には、新しいエントリを辞書に追加する必要があります。
   • また、特定のプレーヤーがキャンバスを持たなくなった場合には、それに応じて辞書からエントリを削除する必要があります。
   • これらの操作によって、「MaybeMyUIPerPlayer」変数の値が変更される可能性があります。

上記の具体例は一部ですが、実際にはプログラムの仕様やアプリケーションの要件に応じて、変数の値が変更される場面はさまざまな場所で発生する可能性があります。

変数が後で値が変更される可能性がある場合には、「var」キーワードを使用して変数を宣言しましょう。

StringToMessage<localizes>(String : string):message = "{String}"

このコードは、与えられた文字列をメッセージオブジェクトに変換する関数を定義しています。

コードの詳細は以下のとおり。

1. StringToMessage<localizes>:
   • これは関数の名前です。「StringToMessage」という名前の関数を定義しています。
   • <localizes>は、可能なローカライゼーション（多言語対応）を示すジェネリック型パラメータです。
2. (String : string):
   • 関数の引数です。
   • 引数の名前は「String」で、型は「string」です。
   • ここでは、変換したい文字列を関数に渡します。
3. :message:
   • 関数の戻り値の型を示しています。
   • この関数では、文字列をメッセージオブジェクトに変換して返します。
4. = "{String}":
   • 関数の本体です。
   • 引数で受け取った文字列を、"{String}"というテンプレートメッセージに埋め込んで返します。
   • つまり、引数で与えられた文字列がそのままメッセージオブジェクトのテキスト部分に設定されます。

この関数は、例えば以下のように使用できます。

let messageObj = StringToMessage<localizes>("Hello, world!")

上記のコードでは、引数として"Hello, world!"という文字列を関数に渡し、関数は"{String}"というメッセージオブジェクトを生成して返します。messageObjには生成されたメッセージオブジェクトが格納されます。

変換前の文字列をメッセージオブジェクトに変換することで、後続の処理で翻訳やローカライズの操作が容易になります。

あすか

    # 指定された文字列をメッセージに変換します。
    StringToMessage<localizes>(String : string):message = "{String}"

このコードでは、関数「StringToMessage」が定義されています。「(String: string)」という部分は、関数の引数を宣言しています。

詳細は以下のとおり。

1. 引数の役割：
   • 引数は、関数に渡されるデータや情報を表します。
   • この場合、「StringToMessage」関数には1つの引数があります。
   • 引数の名前は「String」であり、型は「string」となっています。
   • この引数は、関数が実行される際に外部から渡される文字列の値を受け取ります。
2. 「String: string」として宣言されている理由：
   • 「String: string」は、引数の名前と型を指定しています。
   • 「String」は引数の名前であり、「string」はその引数の型を表します。
   • 具体的には、この関数はある文字列をメッセージに変換するためのものです。
   • ですが、その変換する文字列は外部から渡されるものです。
   • そのため、引数としてこの文字列を受け取る必要があります。
   • 引数の型を「string」と指定することで、関数に渡される値が文字列であることを明示しています。
   • これにより、関数内で引数の値を使ってメッセージを生成する際に、適切な文字列処理や操作を行うことができます。

例えば、以下のような呼び出しを行うことで、この関数を使用することができます:

StringToMessage("Hello, world!")

この場合、引数の「String」には文字列「Hello, world!」が渡されます。そして、関数内ではこの文字列を使ってメッセージを生成し、それを返すことができます。

引数を使用することで、関数はより汎用的になり、異なる入力値に対して適切な処理を行うことができるようになります。

引数の名前、型、必要性は、関数の目的や機能に応じて適切に設計する必要があります。

あすか

    # 指定された文字列をメッセージに変換します。
    StringToMessage<localizes>(String : string):message = "{String}"

上記のコードでは、"message"が型として指定されていますが、これはローカライズ（多言語対応）のためです。

ローカライズでは、文字列をプログラム内で固定のメッセージとして扱うのではなく、メッセージクラスとして扱うことが一般的です。

メッセージクラスは、様々な言語や地域のメッセージを格納するための構造です。

このメッセージクラスは、ユーザーの言語設定や地域に基づいて、適切な言語のメッセージを表示するために使用されます。

上記のコードでは、"StringToMessage"関数が与えられた文字列をメッセージクラスのインスタンスに変換しています。

それにより、将来的に異なる言語に対応するために、プログラムがメッセージのローカライズを容易にできるようになります。

このようにメッセージクラスを使用することで、プログラムは柔軟に多言語対応が可能となり、ユーザーにとってより使いやすいアプリケーションを提供することができます。

あすか

みなみ

英語とか日本語とかいろんな言語に柔軟に対応できるということですね🌸

var ButtonWidgetPerPlayer : [agent]widget = map{}

このコードは、ButtonWidgetPerPlayerという変数を宣言しています。ButtonWidgetPerPlayerは、[agent]widgetという型のマップ（辞書）です。

マップは、キーと値のペアを保持するデータ構造です。このマップでは、エージェント（プレイヤー）をキーとして使用し、それに対応するウィジェット（ボタンなどのインタラクティブな要素）を値として格納します。

この宣言では、ButtonWidgetPerPlayerは空のマップとして初期化されています。プレイヤーごとにウィジェットを追加するための準備が整っています。

例えば、コードの他の部分で以下のように書くことで、プレイヤーとウィジェットを関連付けることができます。

ButtonWidgetPerPlayer[プレイヤー1] = ウィジェット1
ButtonWidgetPerPlayer[プレイヤー2] = ウィジェット2

ここで、プレイヤー1やプレイヤー2はプレイヤーの識別子や名前を表し、ウィジェット1やウィジェット2は対応するプレイヤーに表示するウィジェットのオブジェクトや参照を表します。

このように、ButtonWidgetPerPlayerマップを使用することで、プレイヤーごとに異なるウィジェットを管理できます。

あすか

ButtonWidgetPerPlayerマップは、エージェント（プレイヤー）をキーとして持ち、対応するウィジェットを値として持つデータ構造です。

エージェントはキーであり、ウィジェットはそれに対応する値です。

エージェントはプレイヤーを一意に識別するためのキーとして使用されます。

var EnabledStateMap : [agent]logic = map{}
var VisibleStateMap : [agent]logic = map{}

このコードは、EnabledStateMapとVisibleStateMapという2つの変数を宣言しています。

これらは、ボタンの有効・無効状態と表示・非表示状態をプレイヤーごとに記憶するためのマップ（辞書）です。

EnabledStateMapは、[agent]logic型のマップとして初期化され、VisibleStateMapも同様に[agent]logic型のマップとして初期化されます。

マップはキーと値のペアを保持するデータ構造であり、ここではエージェント（プレイヤー）をキーとして使用し、対応するボタンの有効・無効状態や表示・非表示状態を値として格納します。

初期化時点では、両方のマップは空ですが、以下のようにしてボタンの状態や表示をプレイヤーごとに記憶することができます。

EnabledStateMap[プレイヤー1] = true  // プレイヤー1のボタンを有効化する
VisibleStateMap[プレイヤー1] = false // プレイヤー1のボタンを非表示にする

ここで、プレイヤー1はプレイヤーの識別子や名前を示し、trueはボタンの有効を表し、falseはボタンの無効を表します。

このように、EnabledStateMapとVisibleStateMapマップを使用することで、各プレイヤーに対して異なるボタンの状態や表示を記憶することができます。

EnableWidget(Agent : ?agent) : void =
    # エージェントが有効な場合、ボタンUI要素を有効にする
    if (ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent])
        # ボタンUI要素を有効にする
        ThisButtonWidget.SetEnabled(true)
        # SaveButtonState フラグが true の場合、エージェントの有効状態を保存する
        if (SaveButtonState?):
            # ValidAgent の有効状態を true として保存する
            ValidAgent.SaveEnabledState(true)

EnableWidget(Agent : ?agent): void 関数は、指定されたプレイヤー（Agent）に関連するボタンを有効にするための処理を行います。

詳細は以下のとおり。

1. ValidAgent := Agent?：
   • Agent の値が存在するかどうかを確認します。
   • Agent が存在する場合はその値を ValidAgent に代入します。
   • 存在しない場合は null が代入されます。
2. ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]：
   • ValidAgent に対応するプレイヤーのウィジェットを取得し、ThisButtonWidget という変数に代入します。
   • これにより、プレイヤーごとに設定されたウィジェットを取得できます。
   • もし Agent が null であったり、ButtonWidgetPerPlayer に対応するデータが存在しなかった場合、この部分の処理はスキップされます。
3. ThisButtonWidget.SetEnabled(true)：
   • ThisButtonWidget というウィジェットを有効にするための処理を行います。
   • SetEnabled(true) を呼び出すことで、ウィジェットがクリック可能になります。
4. if (SaveButtonState?)：
   • SaveButtonState が true であるかをチェックします。
   • SaveButtonState が true の場合、次の行の処理が実行されます。
5. ValidAgent.SaveEnabledState(true)：
   • ValidAgent の情報を利用して、ボタンの有効状態を保存するための処理を行います。
   • これによって、ボタンの状態が後から復元されるようになります。

まとめると、EnableWidget 関数は、指定されたプレイヤーに関連するボタンを有効にするための処理を行います。

ボタンのウィジェットを取得し、有効化するだけでなく、必要に応じてその状態を保存することもできます。

あすか

EnableWidget(Agent : ?agent):void=
        if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]):
            ThisButtonWidget.SetEnabled(true)
            if(SaveButtonState?):
                ValidAgent.SaveEnabledState(true)

# EnableWidget関数の定義
# EnableWidget関数の実装
# ThisButtonWidgetの有効化
# SaveButtonState(ボタンの状態をUIを終了しても保持するかどうか)がtrueの場合の処理
# ValidAgent(有効なエージェント)の有効状態を保存

以下に、上記のコードの計算式の論理を解説します。

1. ValidAgent := Agent?：
   • Agent の値が存在するかどうかを確認します。
   • もし存在する場合は、ValidAgent に Agent の値を代入します。
   • もし存在しない場合（Agent が null の場合）、ValidAgent には null が代入されます。
2. ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]：
   • ButtonWidgetPerPlayer 辞書に、ValidAgent のキーが存在するかをチェックします。
   • もし存在する場合は、そのキーに対応するウィジェットが取得され、ThisButtonWidget に代入されます。
   • キーが存在しない場合は、この行の処理はスキップされます。
3. ThisButtonWidget.SetEnabled(true)：
   • ThisButtonWidget というウィジェットの SetEnabled(true) メソッドを呼び出します。
   • これにより、ウィジェットが有効になり、ボタンがクリック可能になります。
4. if (SaveButtonState?)：
   • SaveButtonState の値を確認します。
   • もし SaveButtonState が true の場合、次の行の処理が実行されます。
5. ValidAgent.SaveEnabledState(true)：
   • ValidAgent の SaveEnabledState メソッドを呼び出し、ボタンの有効状態を保存します。
   • これにより、ボタンの状態が後で復元できるようになります。

まとめると、EnableWidget 関数は、指定されたプレイヤーに関連するボタンを有効にするための処理を行います。

プレイヤーが存在し、そのプレイヤーに関連するウィジェットが見つかれば、ボタンを有効化します。もし設定されている場合は、ボタンの状態を保存します。

上記のコードは、特定のエージェントに関連付けられたボタンウィジェットを有効化する関数を定義しています。

また、ボタンの状態を保存するオプションが有効な場合、関連するエージェントの有効状態も保存します。

あすか

想定される問題は以下のとおりです。

1. エージェントの有効性の検証が行われず、無効なエージェントが渡された場合にエラーが発生する可能性があります。
2. エージェントに関連付けられたボタンウィジェットが見つからない場合、ボタンウィジェットの有効化が行われず、適切な対話ができなくなる可能性があります。
3. SaveButtonStateがtrueの場合、エージェントの有効状態を保存する処理が行われないため、ボタンウィジェットの有効状態が次回起動時に保持されない可能性があります。

上記のコードでは、SaveButtonStateがtrueの場合にのみ、エージェントの有効状態を保存する処理が行われます。もしSaveButtonStateがfalseである場合、この保存処理はスキップされるため、ボタンウィジェットの有効状態は次回の起動時に保持されません。

したがって、SaveButtonStateが必要な場合、エージェントの有効状態を保存する処理を実行することが重要です。

これにより、ボタンウィジェットの状態が永続化され、次回のアプリケーション起動時にも正しく復元されるでしょう。

みなみ

一度閉じた際にデータを保存しておくか否かってことですね🌸

「ButtonWidgetPerPlayer」という辞書は、プレイヤーとそれに対応するウィジェットを関連付けて保存しています。この辞書には、例えばプレイヤー名をキーとして、そのプレイヤーに対応するボタンのウィジェットを値として格納していると考えてみましょう。

これを身近な例に置き換えて考えてみると、以下のようなイメージです。

あなたが友達の名前と、その友達に贈るプレゼントを関連付けてリストを作っているとします。

友達の名前（プレイヤー名）とプレゼント（ボタンのウィジェット）が辞書に保存されていて、特定の友達の名前（プレイヤー名）を指定すると、その友達に対応するプレゼント（ボタンのウィジェット）を取得することができます。

具体的な例として、友達「Alice」と「Bob」のウィジェットを保存しておく辞書を考えてみます。

辞書には以下のようにデータが保存されています。

• 辞書「ButtonWidgetPerPlayer」：
• キー「Alice」　=>　ウィジェットA
• キー「Bob」　=>　ウィジェットB

この状況で、もし「ButtonWidgetPerPlayer」辞書から「Alice」に対応するボタンのウィジェットを取得したい場合、ButtonWidgetPerPlayer["Alice"] と指定して辞書にアクセスします。この結果、ウィジェットAが取得されます。

同様に、「Bob」に対応するボタンのウィジェットを取得するには、ButtonWidgetPerPlayer["Bob"] となり、ウィジェットBが取得されます。

しかしこの方法では、存在しないプレイヤー名（キー）を指定してしまった場合にエラーが発生します。

「ButtonWidgetPerPlayer[ValidAgent]」の形式を使えば、プレイヤー名が辞書に存在するかどうかを事前にチェックできるため、エラーを回避することができます。

つまり、「ValidAgent」に「Alice」というプレイヤー名が代入された場合、辞書「ButtonWidgetPerPlayer」には「Alice」のキーが存在し、そのキーに対応するウィジェットが取得されます。同様に、「Bob」なら「Bob」に対応するウィジェットが取得されるわけです。

なお、「キーが存在しない場合は処理をスキップする」というのは、後続のコードブロック（インデントされた部分）が実行されず、次の行に進むということを意味しています。

EnableWidget(Agent : ?agent):void=
        if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]):
            ThisButtonWidget.SetEnabled(true)
            if(SaveButtonState?):
                ValidAgent.SaveEnabledState(true)

if文では、条件が真または偽であるかどうかを判断するための真偽値が期待されます。しかし、nullは真偽値ではありません。そのため、nullの可能性を含む変数やプロパティに対して直接的なチェックを行うことはできません。

ここで、?演算子（オプションチェーン）が登場します。?演算子を使うことで、変数やプロパティがnullである場合でもエラーを回避し、安全にアクセスすることができます。

具体的には、Agent?のように変数やプロパティの直後に?を付けることで、nullのチェックが行われ、nullではない場合に限り評価が進みます。

これにより、nullの可能性を考慮しながら制御フローを実現しています。

りゅう

if 文では null をカバーできないということですね！

? をつけることで、null を許容し、if 文が正常に実行されるようになる。

if 文は、ある条件が真であるかどうかをチェックしますが、null は真でも偽でもない特殊な値です。

そのため、if 文で null をチェックすると、必ずエラーが発生します。

あすか

# ボタンUIをフェードアウト
DisableWidget(Agent : ?agent):void=
    # エージェントの有効性を検証し、ボタンウィジェットを取得します
    if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]):
        # ボタンウィジェットを無効化します
        ThisButtonWidget.SetEnabled(false)
        # SaveButtonStateがtrueの場合、エージェントの有効状態を保存します
        if(SaveButtonState?):
            ValidAgent.SaveEnabledState(false)

このコードは、「DisableWidget」という関数を定義しています。この関数は、与えられたエージェントに関連するボタンウィジェットをフェードアウト (無効化) するためのものです。

具体的な解説は以下のとおり。

1. DisableWidget(Agent : ?agent):void=:
   • 「DisableWidget」という関数を定義します。
   • 関数はAgentという引数を受け取り、戻り値の型はvoidとなります。
2. if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent])::
   • エージェントの有効性を検証し、関連付けられたボタンウィジェットを取得します。
   • この行は"エラットラップ" (エラーを防止するための追加のコード) の一部です。
3. ThisButtonWidget.SetEnabled(false):
   • 取得したボタンウィジェットを無効化します。
   • これにより、ボタンがクリックできなくなります。
4. if(SaveButtonState?): :
   • SaveButtonStateがtrueの場合にのみ、以下の行のコードが実行されます。
   • これは、ボタンの有効状態を保存するオプションが有効かどうかを確認しています。
5. ValidAgent.SaveEnabledState(false):
   • もしSaveButtonStateがtrueであれば、エージェントの有効状態を保存します。
   • この行の意味は、エージェントの有効状態をfalse (無効化) に設定することです。

要約すると、上記のコードは与えられたエージェントに関連するボタンウィジェットをフェードアウト (無効化) する関数を定義しています。

また、ボタンの状態を保存するオプションが有効な場合、関連するエージェントの有効状態も保存します。

このコードのクエリ式は、「エージェントの有効状態を保存するかどうか」をチェックしています。

具体的には、以下の部分です:

if(SaveButtonState?):

この行は、SaveButtonState という変数が「真かどうか」を確認しています。

もし SaveButtonState が真（true）の場合、その下の行で ValidAgent.SaveEnabledState(false) が実行され、エージェントの有効状態が保存されます。

つまり、このクエリ式は「SaveButtonState が true の場合に限り、エージェントの有効状態を保存する」という条件を表現しています。

あすか

まず、条件式は「もし～だったら」のような条件に基づいて、異なる動作をするかを判断するためのものです。

例えば、「雨が降っている場合には傘を持っていく」というような条件があるとします。この場合、「雨が降っているかどうか」をチェックして、その結果に応じて行動を変えます。

次に、クエリ式は単純に「～かどうか」を判断するための式です。例えば、お菓子の箱があって、その中にチョコレートが入っているかを確かめるとします。

このとき、お菓子の箱を開けて中を確認することで、チョコレートが入っているかどうかをクエリ式を使ってチェックします。

だから、条件式はある条件に基づいて分岐したり、違う動作をするための式です。一方、クエリ式は単純に何かの状態をチェックするための式です。

条件式：
もし（プールが混んでいるなら）:
他の遊びをする

クエリ式：
プールが混んでいるかどうかをチェックする

このように、条件式は「もし～だったら」という条件に基づいて決める式で、クエリ式は「～かどうか」を確認するための式として使われます。

条件式は、さまざまな選択肢の間で判断を行い、その結果に応じて異なる行動を選ぶことができます。

例えば、天気が晴れているかどうかを確認して、晴れている場合はピクニックに行く、雨の場合は映画を見る、といった具体的な選択肢があります。

一方、クエリ式は特定の状態を確認するために使用されます。

例えば、お友達に借りた本を探しているときに、「その本は机の上にあるか？」と確認するためにクエリ式を使います。クエリ式は「真か偽か」の状態を返すため、単に情報を確認することに焦点を当てています。

要するに、条件式は選択肢の分岐や判断を行うために用いられ、クエリ式はある状態を確認するために用いられます。

DisableWidget(Agent : ?agent):void=
    if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]):
        ThisButtonWidget.SetEnabled(false)
        if(SaveButtonState?):
            ValidAgent.SaveEnabledState(false)

このコードでは、条件式とクエリ式が組み合わされています。

以下にそれぞれの用途と違いを示します。

条件式:

if(ValidAgent := Agent?, ThisButtonWidget := ButtonWidgetPerPlayer[ValidAgent]):

この条件式では、変数 ValidAgent と ThisButtonWidget が同時に定義されていることを示しています。

条件式の右側で := を使用しているため、これは変数を同時に定義し、代入することを意味します。

条件式の結果として、変数 ValidAgent の値がエージェントとして有効であるかどうかを示し、変数 ThisButtonWidget の値が対応するボタンウィジェットを表します。

この条件式は、変数 Agent の値が有効なエージェントである場合にのみ処理が実行されます。

それ以外の場合、条件式は false と評価され、処理の実行はスキップされます。

クエリ式:

if(SaveButtonState?):
    ValidAgent.SaveEnabledState(false)

このクエリ式では、変数 SaveButtonState の値が真かどうかを確認しています。SaveButtonState? という表記は、変数 SaveButtonState の値が true の場合に条件を満たすことを意味します。

クエリ式の中で、SaveButtonState の値が真の場合のみ処理が実行されます。具体的には、ValidAgent.SaveEnabledState(false) が呼び出され、エージェントの有効状態が保存されます。

ここでの違いは、条件式は特定の条件が満たされた場合に処理を実行するのに対し、クエリ式は特定の条件が真であるかどうかを確認し、その結果に応じて処理を実行するかどうかを決定します。

ここの微妙なニュアンスを例にすると以下のとおり。

あすか

条件式は、条件が満たされた場合に処理を実行するために使用されます。それに対して、クエリ式は条件が真であるかどうかを確認し、その結果に基づいて処理を実行するかどうかを決定します。

例えば、次のシナリオを考えてみましょう。

条件式の例：
「もし雨が降っていたら、傘を持っていく」

クエリ式の例：
「雨が降っているかどうかを確認して、それに基づいて傘を持っていくかどうかを決定する」

条件式では、「雨が降る」という条件が満たされた場合にのみ、「傘を持っていく」という処理が実行されます。

一方、クエリ式では、まず現在の状態を確認して、「雨が降っているかどうか」という条件が真であるかどうかを判定します。もし雨が降っている場合は傘を持っていく、雨が降っていない場合は傘を持たずに出かける、といった具体的な処理を行います。

この例では、条件式は特定の条件が満たされた時に処理を実行しますが、クエリ式は条件を確認してその結果に基づいて処理を実行するかどうかを決定します。

つまり、条件式は条件の成否によって直接的に処理の分岐を決めるのに対し、クエリ式は条件の真偽を確認してから処理の実行可否を決める、という微妙な違いがあると言えます。

あすか

if(SaveButtonState?): ValidAgent.SaveEnabledState(false) の部分では、クエリ式が採用されている理由は次のようなものです：

この部分の目的は、SaveButtonState が true （真）である場合にのみ、ValidAgent.SaveEnabledState(false) を呼び出すことです。つまり、 SaveButtonState の現在の値を確認して、その値に基づいて処理を実行するかどうかを決定する必要があります。

クエリ式で SaveButtonState? という構文を使用したことにより、SaveButtonState の値が真であるかどうかを判断することができます。

もし SaveButtonState が真であれば、クエリ式は真（true）と評価され、その結果として ValidAgent.SaveEnabledState(false) の処理が実行されます。

一方、 SaveButtonState が偽（false）であれば、クエリ式は偽（false）と評価され、処理の実行はスキップされます。

したがって、クエリ式を使用することで、条件式とは異なり、SaveButtonState の値が真であるかどうかを確認してから、それに基づいて処理を実行するかどうかを決定することができます。

もし、if(SaveButtonState): ValidAgent.SaveEnabledState(false) のように条件式が使用されていた場合、条件式は真偽値を直接的にチェックします。

つまり、SaveButtonState の現在の値が真であれば、条件式は真と評価され、その結果として ValidAgent.SaveEnabledState(false) の処理が実行されます。

一方、SaveButtonState の値が偽であれば、条件式は偽と評価され、処理の実行はスキップされます。

条件式を使用する場合、条件が満たされたかどうかに応じて直接的に処理の分岐が行われるため、条件が真であるかどうかを確認するための追加の手順は必要ありません。

したがって、条件式が使用されていた場合、SaveButtonState の値が真であるかどうかを確認してから、それに基づいて処理の実行を決定するという追加の判断が必要ありません。

一方、クエリ式を使用することで、条件の真偽を確認してから処理の実行可否を決定することができます。

この場合、SaveButtonState の現在の値が真であるかどうかをクエリ式で確認して、その結果に基づいて処理の実行を決定します。

結果的に、条件式を使用する場合とクエリ式を使用する場合では、処理の分岐と条件の確認の手順が異なるため、コードの意味や挙動が変わることになります。

つまり、条件式の場合だとSaveButtonStateの値を確認する作業がないということですね。

あすか

条件式を使用する場合、条件式自体が SaveButtonState の値を直接的に確認するので、追加の手順や判断は不要です。

条件式が真であれば処理が実行され、偽であれば処理がスキップされます。条件式を使用すると、特定の条件が満たされているかどうかを直接的に判断できます。

一方、クエリ式を使用する場合は、クエリ式内で SaveButtonState の値を確認して、その結果に基づいて処理を実行するかどうかを決定します。

クエリ式が真であれば処理が実行され、偽であれば処理がスキップされます。

クエリ式を使用すると、条件の確認を行うための手順が追加されますが、条件判断と処理の分岐を同時に行うことができます。

したがって、条件式を使用する場合には追加の手順なしで条件の値を確認し、処理を実行するかどうかを決定できます。

一方、クエリ式を使用する場合には、クエリ式内で条件の値を確認して処理の実行可否を判断することができますが、追加の手順が必要です。

条件の値の確認と処理の実行可否の決定がより明示的かつ慎重に行われると言えます。

あすか

このスクリプトは、ButtonUIというクラスの定義と、そのクラス内で使用されるさまざまなメソッドが含まれています。

詳細は以下のとおり。

1. ButtonUIクラス:

• ButtonText :
  • string型の変数。
  • ボタンのテキストを保持します。
• ButtonPosition :
  • vector2型の変数。
  • ボタンの位置を保持します。
• ButtonSize :
  • vector2型の変数。
  • ボタンのサイズを保持します。
• ButtonStyle :
  • buttonchoice_int型の変数。
  • ボタンのスタイルを保持します。
• RemovesUIOnClick :
  • logic型の変数。
  • ボタンがクリックされたときにUIを削除するかどうかを示します。
• SaveButtonState :
  • logic型の変数。
  • ボタンの状態を保持し、UIを再度開いたときにその状態を反映するかどうかを示します。
• ButtonSignal_Recieve :
  • ButtonUI_UserOptions_Functions型の変数。
  • ボタンの受信信号を格納します。
• ButtonSignal_Send :
  • ButtonUI_UserOptions_Events型の変数。
  • ボタンの送信信号を格納します。
• SizeToContent :
  • logic型の変数。
  • コンテンツに合わせてボタンのサイズを調整するかどうかを示します。
• ButtonWidgetPerPlayer :
  • [agent]widget型のマップ。
  • プレイヤーごとのボタンウィジェットを保持します。
• EnabledStateMap :
  • [agent]logic型のマップ。
  • エージェントごとの有効状態を保持します。
• VisibleStateMap :
  • [agent]logic型のマップ。
  • エージェントごとの表示状態を保持します。

1. EnableWidget(Agent : ?agent):void:

• 指定されたエージェントに対するボタンの有効化を行います。
  • エージェントが有効であれば、関連するボタンウィジェットを有効に設定します。
• SaveButtonStateが有効な場合は、エージェントの有効状態を保存します。

2. DisableWidget(Agent : ?agent):void:

• 指定されたエージェントに対するボタンの無効化を行います。
  • エージェントが有効であれば、関連するボタンウィジェットを無効に設定します。
• SaveButtonStateが有効な場合は、エージェントの有効状態を保存します。

3. (Agent : agent).SaveEnabledState(State : logic):void:

• エージェントごとの有効状態を保存するメソッドです。
• エージェントに対する有効状態のエントリが既に存在するかどうかを調べ、存在する場合はその値を更新し、存在しない場合は新しいエントリを作成します。

4. ShowWidget(Agent : ?agent):void:

• 指定されたエージェントに対するボタンの表示を行います。
  • エージェントが有効であれば、関連するボタンウィジェットを表示します。
• SaveButtonStateが有効な場合は、エージェントの表示状態を保存します。

5. HideWidget(Agent : ?agent):void:

• 指定されたエージェントに対するボタンの非表示を行います。
  • エージェントが有効であれば、関連するボタンウィジェットを非表示に設定します。
• SaveButtonStateが有効な場合は、エージェントの表示状態を保存します。

6. (Agent : agent).SaveVisibleState(State : logic):void:

• エージェントごとの表示状態を保存するメソッドです。
• エージェントに対する表示状態のエントリが既に存在するかどうかを調べ、存在する場合はその値を更新し、存在しない場合は新しいエントリを作成します。

このスクリプトは、ButtonUIクラスを介してボタンの制御や状態の保存を行います。

ボタンの有効性や表示状態、ボタンがクリックされたときに実行する動作などを管理するために使用されることが想定されています。

はい、正しい理解です。(Agent : agent).SaveEnabledState(State : logic) のような表記では、Agent（エージェント）が先に記述される理由は、ボタンの有効状態が特定のエージェントに対してセーブ（保存）されているからです。

この表記方法は、ボタン自体には状態を持たせず、それぞれのエージェントに対して状態を保存するために使用されます。つまり、エージェントごとに異なる状態を持つことができます。

エージェントに関連付けられた個別の状態をセーブすることで、異なるエージェントがそれぞれの状態を独自に管理できるようになります。

条件式（または論理式）は真偽値（trueまたはfalse）を評価するために使用されます。例えば、x > 5という条件式は、変数xが5より大きい場合にtrueを返し、そうでない場合はfalseを返します。

条件式は、プログラムの制御フローを決定するために使用されることがよくあります。

一方、クエリ式は、データベースやデータソースなどのデータを検索するために使用されます。クエリは特定の条件や基準に基づいてデータをフィルタリングしたり、特定の情報を取得したりするために使用されます。

クエリはデータベースクエリ言語（例えばSQL）やデータ処理フレームワーク（例えばLINQ）などを使用して記述されます。

したがって、条件式は真偽値を返し、プログラムの制御フローを制御するために使用され、クエリ式はデータベースからデータを検索するために使用されるという解釈は一般的に正しいです。

制御フロー（Control flow）は、プログラム内の命令やステートメントの実行順序を制御するための仕組みです。

プログラムが逐次的に上から下へ実行されるだけでなく、条件やループなどを使って、特定の条件に応じた処理や繰り返し処理を行うことができます。

制御フローにはいくつかの主要な要素があります。

1. 条件分岐（Conditional branching）:
   • 条件をチェックし、特定の条件が満たされた場合に異なるコードブロックを実行することができます。
   • 例えば、「もし○○ならば、この処理を行い、そうでなければ別の処理を行う」といった形で使われます。
   • 代表的な構文としては、if文やswitch文などがあります。
2. ループ（Looping）:
   • 特定の処理を繰り返し実行することができます。
   • ループは、同じコードブロックを複数回実行するために使用されます。
   • 例えば、配列内のすべての要素に処理を適用する場合や、ある条件が満たされるまで繰り返し処理を行う場合に使われます。
   • 代表的な構文としては、forループやwhileループなどがあります。
3. 分岐（Branching）:
   • プログラムの実行を特定の場所にジャンプさせることができます。
   • 例えば、ある条件に基づいて特定のコードブロックをスキップしたり、ある処理が終了した後に別の処理に移行したりすることができます。
   • 代表的な構文としては、break文やcontinue文などがあります。

これらの制御フローの要素を組み合わせることで、プログラムはより柔軟に振る舞うことができます。

条件によって処理を分岐させたり、ループを使って同じ処理を繰り返したりすることで、複雑なプログラムの制御を容易にすることができます。

制御フローのイメージは下記のサイトを参考にするといいですよ。

>> 制御フローとは