Swiftの分散アクタの紹介

Swiftの分散アクタの紹介

分散アクタとは - Swiftアクタモデルから拡張されたアクタで、分散システムの開発を合理化します。分散Appまたはシステムで作業する際に、分散アクタの分離や位置透過性により、ネットワーク化、シリアル化、他の転送関係での予期せぬ複雑化が回避される仕組みについて解説します。このセッションを最大限に活用するには、WWDC21の「Swiftアクターによるミュータブルステートの保護」をご覧ください。

リソース
関連ビデオ

WWDC22
WWDC21
- Swiftアクターによるミュータブルステートの保護
WWDC19
- ネットワーキングの最新情報（パート2）
ダウンロード

♪ 落ち着いた雰囲気のヒップホップ音楽 ♪ ♪ こんにちは　Konradです Swift teamのエンジニアです『Swiftの分散アクタの紹介』へようこそこのセッションでは単一のプロセスを超えた Swift適合ベースAppについてご紹介します Swift actorは同じプロセスでの低レベルのデータ競合を防ぐためのものでコンパイル時間実行のactor隔離確認で行います分散 actorは同じ概念のactorモデルを改良しクラスタ内の複数のデバイスやサーバなど複数のプロセスに拡張します Swift actorをよくご存じでない方はまず WWDC 2021の『Swiftアクターによるミュータブルステートの保護』をご覧くださいこのセッションで作業するAppは私が最近開発している「Tic Tac Fish」という三目並べに似たゲームですこれの面白い部分はプレイするチームを選択するとそれが絵文字に対応しゲームのコマになるところです盤でコマを動かすとどちらかプレイヤが勝つまで絵文字が盤に配置されます現在はオフラインモードで実装しておりボットと対戦できますが複数プレイヤモードを導入して Appをレベルアップしたいと考えています適合性とゲームのモデルプレイヤを管理するためにすでにactorを使用していますではプレイヤactorを分散 actorを活用して他のプロセスに取り入れる方法を見てみましょうコードに入る前に少し話を戻して actorが適合性と分散型Appに適しているかを説明します WWDCセッションを通してactorについて話す場合「適合性の海」という言葉を聞くでしょうそれはactorについて考えた時いいメンタルモデルになるからです各actorは適合性の海に浮かぶ島でそれぞれの島に直接アクセスする代わりにメッセージを交換し合います Swiftではこのメッセージの送信が async/awaitというメソッドで実行されますこれと actor状態隔離を組み合わせることでコンパイラはactorベースのプログラムがコンパイルされた時に低レベルのデータ競合から解放されます同じ概念のモデルを分散システムとして再考しこのゲームに適用してみますクラスタ内の各デバイスノードオペレーティングシステムのプロセスを個別の適合性の海だと考えますここでは暗い四角で囲まれていますこの中でどちらかというと簡単に情報を同期できますなぜなら同じメモリスペースを共有しているからです同じ概念のメッセージのパスは適合性と分散に対しうまく機能しますがすべてを機能させるには分散にいくつかの制限を加える必要がありますここで分散 actorの登場です分散 actorを使用すると２つのプロセス間のチャネルを設定しメッセージを送信できつまりSwift actorが適合性の海の島であるなら分散 actorは分散システムの海で同じ役割を果たしますプログラミングモデルでは特に変化はなく actorは個々の状態に隔離され非同期メッセージで通信します同じプロセスで分散 actorを増やすこともできますあらゆる点でローカルactorのように便利で違いは必要に応じてリモート通信に参加する準備ができていることですこの分散 actorとのやり取りの方法を変更せずにリモートできる機能を「位置透明性」と呼びますこれは分散 actorのロケーションに関係なく同じ方法で通信できるという意味ですローカルactorで同じことを実行するためのテストに最適であるだけでなく実装を変更することなく actorを位置すべき場所に移動させることができますではコードに移り最初のactorを分散 actorに返還しましょうまず一般的なゲームUIを見て私のプレイヤactorとどう交信するか見てみますこのビューは標準的なSwiftUI コードですゲームフィールドを表現するテキストとボタンの要素がいくつかありますユーザがGameCellをクリックするとプレイヤ actorに移動しビューモデルを更新するようリクエストします Swift Concurrencyのおかげですべての更新は行儀がよくスレッドセーフです現在ユーザ入力を表現するactorはオフラインプレイヤとして実装されています次にそれを見てみましょうこのactorはゲームの動きを生成することを可能にする状態を要約しています具体的にはすでに行われた動きを追跡しどのチームでプレイされているかを追跡します各チームには各動きに対して選択できる絵文字があり動きの数を使用して絵文字キャラクタIDを選択するからです動きが作成されたらモデルを更新する必要がありますモデルはMainActor隔離クラスなのでこの変形はスレッドセーフです userMadeMoveの呼び出しでは「await」を使用する必要があります最後にオフラインプレイヤは対戦相手が動いた時に呼ばれるメソッドを宣言しますここではビューモデルを変更するだけですゲームフィールドがアクティブになり人間のプレイヤは動きを選択しゲーム終了までこのサイクルが続きますボットプレイヤもactorで表現されていますこの実装はビューモデルの更新について心配する必要がなくオフラインプレイヤよりもシンプルです GameStateを追跡しゲームの動きを生成してくれますボットプレイヤはよりシンプルなのでまずこれを分散 actorに変換しましょうコードを使って最初のactorを分散 actorに変換します分散型の「Tic Tac Fish 」にする最初のステップは BotPlayer 型をローカルで使用しながら分散 actorに変換することです Xcodeでそれを行います分散 actorを宣言するには Swift 5.7で紹介された新しい分散型モジュールをインポートする必要がありますこのモジュールには分散 actorを宣言し使用するために必要なすべての型が揃っています分散キーワードをこのようにボットプレイヤactor宣言の前に配置しますこれによりactorは自動的に DistributedActorプロトコルに適合し追加のコンパイル時間確認を有効にできますどんなエラーを修正するようコンパイラに要求されるか見てみましょうコンパイラはBotPlayerが一緒に使用できる actorystemを宣言していないと言っています分散 actorは何らかの分散 actorシステムに属し遠隔呼び出しの実行に必要なシリアル化やネットワーキングを処理しますこのactorが使用しようと意図する actorシステムを宣言する必要があります現在の私の目標はボットプレイヤがすべての遠隔ホストで実行されずに分散隔離検査に合格することなので分散型モジュールに付いてくる LocalTestingDistributedActor システムを使用できますコンパイラに使用するactorシステムをモジュール全体の DefaultDistributedactorystem タイプエリアスで宣言するか特定のactorのactorystem タイプエリアスを使用します後者の方がより具体的なためこれを使用しましょう
次のエラーは「id」プロパティで両方のプレイヤactorが適合する必要のある特定可能プロトコルに適合するために私が手動で実装したものですこのエラーではID プロパティが分散 actorの合成プロパティとの競合で明確に定義できないというメッセージです IDは分散 actorにとって重要な部分です関連の分散 actorシステム全体で actorを一意で特定するのに使用されます actorが初期化されると分散 actorシステムにより割当てられその後そのシステムにより管理されますその場合IDプロパティを手動で宣言したり割当てたりできません actorシステムが代わりに行いますつまりそれはactorシステムに任せて手動で宣言したIDプロパティを削除します最後に修正する必要のあるエラーは分散 actorの初期化子ですコンパイラはactorystemプロパティが使用前に初期化されていないと言っていますこちらもすべての分散 actorの一部であるコンパイラ合成プロパティです使用したいactorシステムの型を宣言するだけでなく合成 actorystem プロパティを具象 actor システムで初期化する必要がありますここで適切なアクションは初期化子でactorシステムを承認しプロパティにパスすることですそうすればテストにある異なるactorシステムの実装にパスして簡単な単体テストを促進できます新しいボットプレイヤを作成するたびにインスタンスをパスする必要があり　今から行います
これで宣言のエラーはすべて解決しましたでもまた呼び出しのエラーに対処する必要があります分散型メソッドのみが遠隔の分散 actorを呼び出せるようですこれはシステム内の一部の actor だけを分散 actorとして注釈するのに似ています分散 actorではすべてのメソッドが遠隔呼び出し向けに設計されたとは限りませんヘルパー機能や呼び出し元がすでに承認されたと推定する関数を使うこともできますそのため Swiftは分散型 API 表面について明確に表現するよう求めています遠隔呼び出し元に露出するためですありがたいことにこの問題はこれらの関数に分散型キーワードを足せば修正できます makeMove とopponentMoved メソッドは遠隔で呼び出されるはずなので両方に分散型キーワードを足します
これで最後の問題が片付きました分散型メソッド呼び出しはネットワーク境界を越えるためすべてのパラメータとリターン値が actorシステムでシリアル化要件に適合するのを確実にする必要がありますここではactorシステムは Codableを使用しています Swift のネイティブシリアル化メカニズムですコンパイラは具体的に「結果型 GameMove がシリアルか要件Codableに適合していない」と言っていますなので GameMove型を見てみましょうはっきりしたデータ型のようで必要な適合性を追加すれば簡単にコード化可能にできるようです Swiftコンパイラは必要なコード化可能の実装を合成してくれますこれで完了期待通りにゲームが実行されるでしょう
魚チームに１点どちらのプレイヤも同じローカルデバイスで実行されていますが次のステップのためにすでに下準備ができていますこのステップではボットプレイヤが新しく得た位置透過性能力の恩恵を受けますこれに使用するためのWebSocketベースのサンプルのactorシステムをすでに準備してありますこのactor システムを使用することでボットプレイヤをサーバーサイドの Swift Appに移動させこのモバイルゲームからリモート参照をresolveします actorに関しては宣言されたactorシステムを LocalTesting DistributedActorシステムから私がサンプルAppで用意した SampleWebSocketactorystemに変更するだけです残りの actor コードは同じです次は遠隔ボットプレイヤ参照をローカルで作成せずに問題を解決します分散 actorにおいて「ローカル」と「遠隔」という用語は観点によるものですすべての遠隔参照には分散 actor システムのその他のノードでローカルインスタンスと一致しています分散 actorのローカルインスタンスの作成は他のSwift オブジェクトと初期化子を呼び出し同じ方法で行われますしかし分散 actor に遠隔参照を得ることはパターンが少し異なります actorを作成する代わりに具象 actor システムで actor IDの問題を解決します静的resolveメソッドによりactor システムにそのIDを持つ actorのactorインスタンスを渡すようリクエストするか IDにより特定されたactorに遠隔参照を与えるよう依頼します actor システムは識別子をresolveする際に遠隔検索を行うべきではありません　なぜなら resolveメソッドは非同期ではないためすばやくリターンしネットワーキングの実行を防がないと操作を中断させてしまいます識別は有効な遠隔ロケーションでは有効に見えてもシステムはそのactorが存在するとみなし遠隔参照をリターンします IDをresolveする際に忘れてはいけないのは遠隔システムの実際のインスタンスはまだ存在していない可能性があることですたとえばここではゲームの対戦相手となる敵のボットプレイヤを適当に作りましたこのボットはまだ存在しませんがこのIDが受信するよう割当てられた最初のメッセージとしてサーバ側に作成されていますサーバ側のSwift Appですが私が準備したサンプルの WebSocket actorシステムで簡単に実装することができますまずサーバモードでWebSocket actorシステムを作成しますこれはポートを接続ではなく結び付け内容を聞きますそしてシステムが終了するまでAppを待たせます次はまだインスタンスが割当てられていない IDに向けられたメッセージを受信した時のためにオンデマンドで作成する actorのパターンに対処する必要があります一般的にactorシステムはメッセージを受信しローカル分散 actor インスタンスを見つけるため受信者IDを解決しようとし位置が判明したactorで遠隔呼び出しを行いますしかし先程お話ししたようにボットプレイヤのIDは適当につけたものなのでシステムはそれらを知ることができず自身で適切なactorの型を書きますしかしサンプルのactor システム実装のおかげでオンデマンドのactor作成用に適切なパターンが十分に作成されていますここで注意して頂きたいのはこれはただのパターンで分散 actorモジュールが構築したものや提供するものではありませんしかしactorシステムの実装がいかに柔軟で強力かを示す例となりますシステムはさまざまなパターンを提供し複雑なタスクの処理を容易にしてくれますこのパターンの使用によりactorシステムは通常通りすべての受信IDのローカルactorを解決しますしかし既存のactorを見つけられない場合 resolveCreateOnDemandを試みます私たちは両方のクライアントコードを管理するため IDとサーバコードの一部を作り上げ必要なactorをオンデマンドで作成して actorシステムを支援することができますクライアントで適当に作ったボットの識別子が「ActorIdentityにタグを追加」など一般的な命名スキームを使用するかはっきりした名前を使用するためこれらのIDを検知しまだactiveが１つもないすべてのメッセージに対しボット対戦者を作成できます新しいボットは指定された最初のメッセージにのみ作成します後続の遠隔呼び出しはただ既存のインスタンスをresolveするだけです以上ですサーバ実装は完了したので遠隔ボットプレイヤとゲームができますコマンドラインからシステムを実行するか Xcodeでサーバスキームを選択し通常通り「実行」をクリックします最初の動きをしたところで作成した遠隔プレイヤ参照で makeMoveを呼びボットに同じ事をさせますサーバ側のシステムでresolveがトリガされますこのIDの既存のボットが見つからないのでオンデマンドでボットを作成しますボットはmakeMove呼び出しを受け生成されたGameMoveで応答しますすでにすばらしいゲームになりましたボットプレイヤを分散actorに変換する前面の作業を行いましたが遠隔システムに移動するのはわりと簡単でしたネットワーキングやシリアル化実装の詳細に携わる必要はありませんでしたすべての重量な仕事は分散 actorシステムが行いましたそしてまだ強化されたフィーチャーコンプリートの実装はありませんがこの機能ではこのような簡単な配信を目指してきました次はこのゲームに真のマルチプレイヤ体験を構築しましょう先程の例ではクライアント/サーバシナリオで分散actorを使用しましたきっと他のAppを開発したことでご存じでしょうしかし分散 actorは専用のサーバコンポーネントがないピアツーピアシステムでも使用できますこれをこのゲームの別のアイデアに使用します時々旅先でインターネットの接続があまりよくなくでもローカルWi-Fiがすばらしく機能することがありますでも友達に挑戦してゲームで遊びたいと思います同じネットワークに接続した場合に今のような状況が起こったとしましょう別のactorシステム実装を実装しました今度はネットワークフレームワークが提供するローカルネットワーキング機能を使用します actorシステムの実装についてはこのトークでは説明しませんが WWDC 2019の『ネットワーキングの最新事情（パート２）』でこれを学ぶことができますまたローカルネットワークへのアクセスは機密情報をさらすことにもなりかねませんなので慎重に扱ってください今回は既存の他のデバイスの分散actorを使用するので先程の例ようにローカルIDを作り上げることはできませんゲームで遊びたい別のデバイスの特定のactorを見つけますこの問題は分散actorでは特別ではなくサービスディスカバリ機構で解決できますが分散actorのドメインでは actorシステムが期待する一般的なパターンと APIの様式がありそれによりすべてのコードで強く型付けされたAPIを利用することができますこれは受付パターンと呼ばれています actorは他のものと出会うためにホテルのようにチェックインするからです各actorシステムには専用の受付がおり基本的なトランスポート機構に最適な方法で actor発見可能性を実行します既存のサービス発見性APIを使用することもあり型安全APIの層だけが上にありますまたはゴシップベースの機構を使用するか完全に別のものを使用しますしかしこれはユーザのactorシステムの観点からの実装の詳細なので大切なのはactorが発見可能にすることで発見が必要な時にタグか型で検索できるようにすることだけです SampleLocal Networkactorystem向けに実装したシンプルな受付をお見せしましょう actorがチェックインすると分散actorシステムのすべての受付がそのactorを発見しますそうすると特定の型のactorのリストを取得しそのシステムで利用可能になるとタグを付けますではこの受付を使ってゲームの対戦相手にしたい具象の対戦相手actorを見つけましょう先程GameViewは対戦相手をビュー初期化子で直接作成…resolveしましたここではそれができません相手がネットワークに現れるまで非同期で待つ必要があるからですこれを行うには見つかるのを待つ間に「Looking for　opponent」というメッセージを表示するマッチメイキングビューを使用しますこのビューが表示されたらマッチングメイキングが始まりこれは対戦チームのタグを使用しローカルactorシステムの受付にタグ付けされたすべてのactorのリストを要求する非構造化タスクで行われます魚チームでプレイする場合相手にネズミチームを探したりその反対が行われたりします次に敵のactorのawaitに async for loopを使用しますシステム対戦相手のいるデバイスを発見するとタスクループが再開します相手はプレイする準備が万端なら即座にモデルに保管されゲームを開始できますヘルパー機能を使用して誰が先手を打つか決め対戦相手に対決したいことを伝えます async for loopを解除するためにここに戻りますマッチングは１人しか必要ないからですこのgameplayモードでは OfflinePlayerの実装を少し変更します LocalNetworkPlayerと名付けましょう SampleLocalNetworkactorystemが使用されますここで興味深いのは人間のプレイヤを代表する actorが遠隔で呼び出される点ですしかし手を打つのは人間のプレイヤの責任ですこの課題を解決するためにビューモデルに非同期の関数 humanSelectedFieldを導入します人間のユーザーが１つのフィールドでクリックするとトリガーし@Published値により起動します人間のプレイヤがフィールドをクリックすると makeMove関数が再開し実行されたGameMoveを遠隔呼び出し元に返すことで完了しますこれも以上で完了です actor実装を少し変更して真の複数プレイヤゲームモードにしましたがシステムの全体的な設計は特に変更されていません最も重要なのはゲームロジックが変更されていない点がローカルネットワークの使用を具体的にしましたプレイヤactorで分散メソッドを呼び出し対戦相手とゲームができるようになりましたこれを実演するには対戦相手が必要ですアシスタントのカパビラにお願いしましょうかなり凄腕だそうです
彼は頭がいいですね
なかなか上手い私はここにおっと負けた！今回は彼が勝ちましたがまた今度対戦しますカピバラありがとうでは最後になりますが異なるactorシステムを組み合わることにより何を達成できるかをご紹介します例えば WebSocketシステムを使用してサーバ側のロビーシステムのデバイスホストのactorプレイヤ actorを登録しその間の分散呼び出しのプロキシにすることができます GameLobby actorを実装するとデバイスホストのプレイヤ actorが自身で登録できるようになりますデバイスがオンラインモードに入ると受付を使ってGameLobbyを発見し呼び出しが始まります GameLobbyは利用可能なプレイヤを探しプレイヤのペアが特定されるとゲームセッションを開始しますゲームセッションは推進者となり動きをポーリングしサーバに保管されたゲーム表現に記録しますゲームが終了すると結果を収集してロビーに報告しますさらに興味深いのはこの設計を水平に拡大できる点です単一サーバでより多くの適合性を提供するためにゲームセッションactorを増やすこともできますが分散 actorのおかげで他のノードでゲームセッションを作成しクラスタ全体でゲーム適合数をロードバランスできますそれはクラスタ actorシステムがある場合のみ実はそれもあります！そのようなシナリオではオープンソース Cluster Actorシステムライブラリを利用できます SwiftNIOで実装されサーバ側データセンタのクラスタリングに特化しています失敗検知のための高度技術があり自身のクラスタ全体の受付の実装が付いてきますどちらもactorシステムの actorシステムの高度参照実装で強力なサーバ側のAppとなりますので是非お試しくださいではまとめです最初に分散actorについて学び追加のコンパイラ支援のactor隔離とシリアル化検査について学びましたロケーション透過方法についてと actorを呼び出し元と同じプロセスが行われる場所から解放する方法を学び分散actorを使用して何かを構築することを奨励するためにactorシステムの実装の実演をお見せしました分散actorは使用されるactorシステムと効力が同じですそのため皆さんのために actorシステムのリストをここでお見せしましょう Swiftでデフォルトのローカルテストシステム２つのactorシステムのサンプルクライアント/サーバ式 WebSocketベースのものとローカルネットワーキングベースのシステムですこれらはまだ完成しておらず分散actorを使用して何かを構築するためのインスピレーションのようなものですこれはこのセッションに関連するサンプルコードAppで確認することができます最後にオープンソースの完全機能のサーバ側のクラスタ実装ですベータ版として現在ご利用いただけ Swift 5.7.と共に成長していくでしょう分散actorの詳細については次のリソースをご覧くださいこのセッションで使用したサンプルコード「Tic Tac Fish」で辿った手順がすべて記載されておりコードを詳細に確認できます分散actor言語機能に関連する Swift evolution proposalではメカニズムが詳細に説明されていますまたSwiftフォーラムにアクセスするとデベロッパやユーザに役に立つactorシステムの分散actorのカテゴリが見つかりますご清聴ありがとうございました皆さんのAppで分散actorが活用されるのが楽しみです ♪

public actor OfflinePlayer: Identifiable {
    nonisolated public let id: ActorIdentity = .random

    let team: CharacterTeam
    let model: GameViewModel
    var movesMade: Int = 0

    public init(team: CharacterTeam, model: GameViewModel) {
        self.team = team
        self.model = model
    }

    public func makeMove(at position: Int) async throws -> GameMove {
        let move = GameMove(
            playerID: id,
            position: position,
            team: team,
            teamCharacterID: team.characterID(for: movesMade))
        await model.userMadeMove(move: move)

        movesMade += 1 
        return move
    }

    public func opponentMoved(_ move: GameMove) async throws {
        do {
            try await model.markOpponentMove(move)
        } catch {
            log("player", "Opponent made illegal move! \(move)")
        }
    }

}

5:39 - actor BotPlayer

public actor BotPlayer: Identifiable {
    nonisolated public let id: ActorIdentity = .random
    
    var ai: RandomPlayerBotAI
    var gameState: GameState
    
    public init(team: CharacterTeam) {
        self.gameState = .init()
        self.ai = RandomPlayerBotAI(playerID: self.id, team: team)
    }
    
    public func makeMove() throws -> GameMove {
        return try ai.decideNextMove(given: &gameState)
    }
    
    public func opponentMoved(_ move: GameMove) async throws {
        try gameState.mark(move)
    }
}

6:11 - distributed actor BotPlayer

import Distributed 

public distributed actor BotPlayer: Identifiable {
    typealias ActorSystem = LocalTestingDistributedActorSystem
  
    var ai: RandomPlayerBotAI
    var gameState: GameState
    
    public init(team: CharacterTeam, actorSystem: ActorSystem) {
        self.actorSystem = actorSystem // first, initialize the implicitly synthesized actor system property
        self.gameState = .init()
        self.ai = RandomPlayerBotAI(playerID: self.id, team: team) // use the synthesized `id` property
    }
    
    public distributed func makeMove() throws -> GameMove {
        return try ai.decideNextMove(given: &gameState)
    }
    
    public distributed func opponentMoved(_ move: GameMove) async throws {
        try gameState.mark(move)
    }
}

12:08 - Resolving a remote BotPlayer

let sampleSystem: SampleWebSocketActorSystem

let opponentID: BotPlayer.ID = .randomID(opponentFor: self.id)
let bot = try BotPlayer.resolve(id: opponentID, using: sampleSystem) // resolve potentially remote bot player

13:35 - Server-side actor system app

import Distributed
import TicTacFishShared

/// Stand alone server-side swift application, running our SampleWebSocketActorSystem in server mode.
@main
struct Boot {
    
    static func main() {
        let system = try! SampleWebSocketActorSystem(mode: .serverOnly(host: "localhost", port: 8888))
        
        system.registerOnDemandResolveHandler { id in
            // We create new BotPlayers "ad-hoc" as they are requested for.
            // Subsequent resolves are able to resolve the same instance.
            if system.isBotID(id) {
                return system.makeActorWithID(id) {
                    OnlineBotPlayer(team: .rodents, actorSystem: system)
                }
            }
            
            return nil // unable to create-on-demand for given id
        }
        
        print("========================================================")
        print("=== TicTacFish Server Running on: ws://\(system.host):\(system.port) ==")
        print("========================================================")
        
        try await server.terminated // waits effectively forever (until we shut down the system)
    }
}

20:02 - Receptionist listing

/// As we are playing for our `model.team` team, we try to find a player of the opposing team
let opponentTeam = model.team == .fish ? CharacterTeam.rodents : CharacterTeam.fish

/// The local network actor system provides a receptionist implementation that provides us an async sequence
/// of discovered actors (past and new)
let listing = await localNetworkSystem.receptionist.listing(of: OpponentPlayer.self, tag: opponentTeam.tag)
for try await opponent in listing where opponent.id != self.player.id {
    log("matchmaking", "Found opponent: \(opponent)")
    model.foundOpponent(opponent, myself: self.player, informOpponent: true)
    // inside foundOpponent:
    // if informOpponent {
    //     Task {
    //         try await opponent.startGameWith(opponent: myself, startTurn: false)
    //     }
    // }

    return // make sure to return here, we only need to discover a single opponent
}

20:23 - distributed actor LocalNetworkPlayer

public distributed actor LocalNetworkPlayer: GamePlayer {
    public typealias ActorSystem = SampleLocalNetworkActorSystem

    let team: CharacterTeam
    let model: GameViewModel

    var movesMade: Int = 0

    public init(team: CharacterTeam, model: GameViewModel, actorSystem: ActorSystem) {
        self.team = team
        self.model = model
        self.actorSystem = actorSystem
    }

    public distributed func makeMove() async -> GameMove {
        let field = await model.humanSelectedField()

        movesMade += 1
        let move = GameMove(
            playerID: self.id,
            position: field,
            team: team,
            teamCharacterID: movesMade % 2)

        return move
    }

    public distributed func makeMove(at position: Int) async -> GameMove {
        let move = GameMove(
            playerID: id,
            position: position,
            team: team,
            teamCharacterID: movesMade % 2)

        log("player", "Player makes move: \(move)")
        _ = await model.userMadeMove(move: move)

        movesMade += 1
        return move
    }

    public distributed func opponentMoved(_ move: GameMove) async throws {
        do {
            try await model.markOpponentMove(move)
        } catch {
            log("player", "Opponent made illegal move! \(move)")
        }
    }

    public distributed func startGameWith(opponent: OpponentPlayer, startTurn: Bool) async {
        log("local-network-player", "Start game with \(opponent.id), startTurn:\(startTurn)")
        await model.foundOpponent(opponent, myself: self, informOpponent: false)

        await model.waitForOpponentMove(shouldWaitForOpponentMove(myselfID: self.id, opponentID: opponent.id))
    }
}

特定のトピックをお探しの場合は、上にトピックを入力すると、関連するトピックにすばやく移動できます。

クエリの送信中にエラーが発生しました。インターネット接続を確認して、もう一度お試しください。

リソース

関連ビデオ

WWDC22

WWDC21

WWDC19