GoおよびWebSocketでマルチプレイヤーゲームを作成する

私たちはGoプログラミング言語（golang）の知識を継続しています。 前回は、基本的な言語構造について見てきました。 この記事では、ゴルーチンとチャネルの使用方法を示します。 そして、もちろん、このすべてを実際のアプリケーション（この場合はマルチプレイヤーゲーム）で実演します。 ゲーム全体ではなく、WebSoketを介したプレーヤー間のネットワーク相互作用を担当するバックエンドの部分のみを考慮します。

ゲームは2人のプレイヤーのためのターンベースです。 ただし、以下で説明する手法は、ポーカーから戦略まで、他のゲームを作成するために使用できます。

ちなみに、これは私の最初のゲームであり、WebSocketでの最初の仕事なので、厳密に判断しないでください。 コメントや合理的な批判があれば、喜んで聞きます。

アルゴリズムは次のとおりです。 プレイヤーはゲームルーム（部屋）に接続します。 プレーヤーから新しい動きが届くと、ルームに（チャネル経由で）これが通知され、ルームに登録されているすべてのプレーヤーで「ゲーム状態の更新」という特別なメソッドが呼び出されます。 すべてが非常に簡単です。

概略的に、これは次のように表すことができます。



プレーヤーとの通信は、「接続」レイヤーオブジェクト（図pConn1、pConn2）を介して行われます。このオブジェクトは、プレーヤータイプを（それ自体に埋め込むことにより）拡張し、通信のためのメソッドを追加します。

ちなみに、オブジェクトのOOPの意味ではなく、エンティティの指定として「オブジェクト」という言葉を使用することがあります（移動中は若干異なるため）。

プロジェクトの構造を考慮してください。

/wsgame/ /game/ game.go /templates/ /utils/ utils.go main.go conn.go room.go 

ルートファイル（メインパッケージ）に、ネットワークの相互作用が実装されています。
/ game /パッケージには、ゲームエンジン自体が含まれています。 私たちはそれを考慮しません。ここでは、ゲームを制御するために必要な、モックの形でいくつかのメソッドのみを提供します。

ゲーム

/game/game.go

 package game import ( "log" ) type Player struct { Name string Enemy *Player } func NewPlayer(name string) *Player { player := &Player{Name: name} return player } func PairPlayers(p1 *Player, p2 *Player) { p1.Enemy, p2.Enemy = p2, p1 } func (p *Player) Command(command string) { log.Print("Command: '", command, "' received by player: ", p.Name) } func (p *Player) GetState() string { return "Game state for Player: " + p.Name } func (p *Player) GiveUp() { log.Print("Player gave up: ", p.Name) } 

プレイヤー（プレイヤー）には、同じプレイヤーである敵がいます（この構造では、これは*プレイヤーポインターです）。 プレーヤーを接続するには、PairPlayers関数を使用します。 さらに、ゲームの制御に必要な機能の一部を以下に示します。 ここでは何もせず、コンソールにメッセージを表示するだけです。 コマンド-コマンドを送信（移動）; GetState-このプレーヤーのゲームの現在の状態を取得します。 ギブアップ-降伏し、対戦相手に勝利を割り当てます。

UPD：その後、1つのゲームに1つのPlayer構造しか持たないことはあまり便利ではないことが判明しました。 プレイヤーが接続されているゲーム構造を作成することをお勧めします。 しかし、それは別の話です。

メイン

main.go

 package main import ( "github.com/alehano/wsgame/game" "github.com/gorilla/websocket" "html/template" "log" "net/http" "net/url" ) const ( ADDR string = ":8080" ) func homeHandler(c http.ResponseWriter, r *http.Request) { var homeTempl = template.Must(template.ParseFiles("templates/home.html")) data := struct { Host string RoomsCount int }{r.Host, roomsCount} homeTempl.Execute(c, data) } func wsHandler(w http.ResponseWriter, r *http.Request) { ws, err := websocket.Upgrade(w, r, nil, 1024, 1024) if _, ok := err.(websocket.HandshakeError); ok { http.Error(w, "Not a websocket handshake", 400) return } else if err != nil { return } playerName := "Player" params, _ := url.ParseQuery(r.URL.RawQuery) if len(params["name"]) > 0 { playerName = params["name"][0] } // Get or create a room var room *room if len(freeRooms) > 0 { for _, r := range freeRooms { room = r break } } else { room = NewRoom("") } // Create Player and Conn player := game.NewPlayer(playerName) pConn := NewPlayerConn(ws, player, room) // Join Player to room room.join <- pConn log.Printf("Player: %s has joined to room: %s", pConn.Name, room.name) } func main() { http.HandleFunc("/", homeHandler) http.HandleFunc("/ws", wsHandler) http.HandleFunc("/static/", func(w http.ResponseWriter, r *http.Request) { http.ServeFile(w, r, r.URL.Path[1:]) }) if err := http.ListenAndServe(ADDR, nil); err != nil { log.Fatal("ListenAndServe:", err) } } 

これは、プログラムへのエントリポイントです。 main（）関数はサーバーを起動し、2つのハンドラーを登録します。home.htmlテンプレートのみを表示するメインページのhomeHandlerと、WebSocket接続を確立してプレーヤーを登録するより興味深いwsHandlerです。

WebSocketの場合、Gorilla Toolkitのパッケージ（ "github.com/gorilla/websocket"）を使用します。 最初に、新しい接続（ws）を作成します。 次に、URLパラメーターからプレーヤーの名前を取得します。 次に、無料の部屋（プレイヤー1人）を探します。 スペースがない場合は、作成します。 その後、プレーヤーとプレーヤーの接続オブジェクト（pConn）を作成します。 Webソケット、プレーヤー、および部屋を接続に転送します。 より正確には、これらのオブジェクトにポインターを渡します。 最後のステップは、接続を部屋に接続することです。 これは、オブジェクトをルームの参加チャンネルに送信することにより行われます。

ゴルーチンとチャンネル

ゴルーチンとチャンネルに関する小さな教育プログラム。 ゴルーチンはスレッドのようなもので、並行して実行されます。 関数呼び出しの前にgoステートメントを置くだけで十分です。プログラムは、関数が完了するまで待機せず、すぐに次の命令に進みます。 ゴルチンは非常に軽量で、メモリを必要としません。 ゴルーチンとの通信は、特別なデータ型であるチャネルを介して行われます。 パイプはUnixのパイプに似ています。 チャネルをパイプとして想像できます。一方に何かを置き、もう一方から取得します。 チャネルのタイプは任意です。 たとえば、文字列チャネルを作成してメッセージを送信できます。 チャンネルフィードを作成することもできます。 もっと深くする必要があります。

小さな例。 ここで実行できますhttp://play.golang.org/p/QUc458nBJY
同じリクエストを複数のサーバーに送信し、より速く応答するサーバーから応答を取得するとします。 そして、残りを待ちたくない。 次の方法で実行できます。

 package main import "fmt" func getDataFromServer(resultCh chan string, serverName string) { resultCh <- "Data from server: " + serverName } func main() { res := make(chan string, 3) go getDataFromServer(res, "Server1") go getDataFromServer(res, "Server2") go getDataFromServer(res, "Server3") data := <- res fmt.Println(data) } 

応答を受け取るresチャネルを作成します。 そして、別のゴルーチンで、サーバーへのリクエストを開始します。 操作はブロックされないため、go演算子を使用した行の後、プログラムは次の行に移動します。 Dalle、プログラムは行data := <- resブロックされていdata := <- res 、チャネルからの応答を待っています。 回答が受信されるとすぐに、画面に表示され、プログラムが終了します。 この合成例では、Server1からの応答が返されます。 しかし、実際には、リクエストに異なる時間がかかる場合、最速のサーバーからの応答が返されます。

UPD：チャンネルの作成中の番号3は、チャンネルがバッファーされていることを示します。サイズ3。これは、チャンネルに送信するとき（空きスペースがある場合）、誰かがデータを受信するまで待つ必要がないことを意味します。 この場合、これはできませんでした。 とにかくプログラムは終了します。 しかし、たとえば、常に動作するWebサイトであり、チャネルがバッファリングされない場合、3つのゴルーチンのうち2つがフリーズし、反対側での受信を待機します。

それでは、ラムに戻りましょう。

接続

conn.go

 package main import ( "github.com/alehano/wsgame/game" "github.com/gorilla/websocket" ) type playerConn struct { ws *websocket.Conn *game.Player room *room } // Receive msg from ws in goroutine func (pc *playerConn) receiver() { for { _, command, err := pc.ws.ReadMessage() if err != nil { break } // execute a command pc.Command(string(command)) // update all conn pc.room.updateAll <- true } pc.room.leave <- pc pc.ws.Close() } func (pc *playerConn) sendState() { go func() { msg := pc.GetState() err := pc.ws.WriteMessage(websocket.TextMessage, []byte(msg)) if err != nil { pc.room.leave <- pc pc.ws.Close() } }() } func NewPlayerConn(ws *websocket.Conn, player *game.Player, room *room) *playerConn { pc := &playerConn{ws, player, room} go pc.receiver() return pc } 

中間層とは何ですか？ これは、Webソケット、プレーヤー、ルームへのポインターを含むplayerConnオブジェクトです。 プレーヤーの場合、* game.Playerと記述しました。 つまり、Playerを「埋め込み」、playerConnでそのメソッドを直接呼び出すことができます。 継承のようなもの。 新しい接続（NewPlayerConn）を作成すると、レシーバーメソッドが別のゴルーチン（goステートメント）で起動されます。 並行して（非ブロック方式）、無限ループでメッセージのWebソケットをリッスンします。 それを受け取ると、Commandメソッドでプレーヤーに渡されます（移動します）。 そして、「すべてのプレイヤーのゲームの状態を更新する」信号を部屋に送ります。 エラー（たとえば、Webソケットのブレーク）が発生した場合、goroutinはループから出て、「surrender」信号をルームチャネルに送信し、Webソケットを閉じて終了します。
sendState（）メソッドを使用して、ゲームの現在の状態をこのプレーヤーに送信します。

部屋

room.go

 package main import ( "github.com/alehano/wsgame/game" "github.com/alehano/wsgame/utils" "log" ) var allRooms = make(map[string]*room) var freeRooms = make(map[string]*room) var roomsCount int type room struct { name string // Registered connections. playerConns map[*playerConn]bool // Update state for all conn. updateAll chan bool // Register requests from the connections. join chan *playerConn // Unregister requests from connections. leave chan *playerConn } // Run the room in goroutine func (r *room) run() { for { select { case c := <-r.join: r.playerConns[c] = true r.updateAllPlayers() // if room is full - delete from freeRooms if len(r.playerConns) == 2 { delete(freeRooms, r.name) // pair players var p []*game.Player for k, _ := range r.playerConns { p = append(p, k.Player) } game.PairPlayers(p[0], p[1]) } case c := <-r.leave: c.GiveUp() r.updateAllPlayers() delete(r.playerConns, c) if len(r.playerConns) == 0 { goto Exit } case <-r.updateAll: r.updateAllPlayers() } } Exit: // delete room delete(allRooms, r.name) delete(freeRooms, r.name) roomsCount -= 1 log.Print("Room closed:", r.name) } func (r *room) updateAllPlayers() { for c := range r.playerConns { c.sendState() } } func NewRoom(name string) *room { if name == "" { name = utils.RandString(16) } room := &room{ name: name, playerConns: make(map[*playerConn]bool), updateAll: make(chan bool), join: make(chan *playerConn), leave: make(chan *playerConn), } allRooms[name] = room freeRooms[name] = room // run room go room.run() roomsCount += 1 return room } 

最後の部分は部屋です。 いくつかのグローバル変数を作成します：allRooms-作成されたすべての部屋のリスト、freeRooms-1人のプレーヤーがいる部屋（理論上は複数はないはずです）、roomsCount-作業部屋のカウンター。

ルームオブジェクトには、ルームの名前、playerConns-接続された接続（プレーヤー）のリスト、および制御用の複数のチャネルが含まれます。 チャネルにはさまざまなタイプがあります。これは、チャネルとの間で送受信できるものです。 たとえば、updateAllチャネルにはブール値が含まれており、ゲームの状態を更新する必要があるかどうかを通知するだけです。 何が送信されるかは問題ではなく、その操作にのみ反応します。 確かに、この場合は空の構造体{}を使用することをお勧めします。 ただし、特定の接続（またはむしろそれへのポインター）は、参加チャネルに転送されます。 マップ構造のキーとして、playerConnsの部屋に保存します。

NewRoom（）を使用して新しいルームを作成する場合、チャネルを初期化し、goroutineでrun（）メソッドを実行します（go room.run（））。 複数のチャネルを同時にリッスンする無限ループを実行し、いずれかのチャネルでメッセージを受信すると、特定のアクションを実行します。 複数のチャンネルをリッスンするには、select-caseコンストラクトを使用します。 この場合、操作はブロックされています。 つまり メッセージがいずれかのチャネルから到着するまで待機してから、ループの次の反復に進み、再度待機します。 ただし、selectコンストラクトにdefault：セクションがある場合、操作はブロックされず、メッセージがない場合はデフォルトブロックが実行され、selectを終了します。 この場合、それは無意味ですが、そのような機会があります。

参加チャンネルがトリガーされた場合、この接続を（プレイヤーの）ルームに登録します。 2番目のプレーヤーが接続した場合、プレーヤーを「ペアリング」し、無料のプレーヤーのリストから部屋を削除します。 休暇がトリガーされたら、接続を削除し、プレーヤーで「surrender」メソッドを実行します。 ルームlen（r.playerConns）== 0にプレイヤーが残っていない場合、通常はループを終了して（goto Exit）ルームを閉じます。 はい、goにはgotoステートメントがあります。 しかし、心配しないでください。めったに使用されず、forやselectなどの構造を終了するためだけに使用されます。 たとえば、ネストされたループを終了します。 この場合、ブレークを設定すると、forループではなく、select構文が中止されます。

そして最後に、updateAllチャネルがトリガーされると（送信された値は重要ではないため、どこにも保存しません：case <-r.updateAll）、部屋に登録されているすべてのプレイヤーに対してメソッド「ゲーム状態の更新」が呼び出されます。

これがネットワーク全体です。 実際のプロジェクトでは、もう少し複雑になりました。 チャットとタイマーを担当するチャネルと、何らかの種類のリクエスト/レスポンス構造（JSONに基づく）を追加しました。

このようなバックエンドを使用すると、さまざまなデバイスでクライアントを作成するのは非常に簡単です。 クロスプラットフォーム用のHTML5クライアントを作成することにしました。 iOSでは、ゲームは常にクラッシュしますが。 websocketサポートが完全に実装されていないことがわかります。

ご清聴ありがとうございました。 Goでのプログラミングは楽しいです。

参照：

• GitHubおよびデモゲームのファイル： https : //github.com/alehano/wsgame