TRON — Network Game — Julien Quenneville

Overview

My first networked game, written on Linux: a multiplayer TRON light-cycle game after the 1982 film. Ride your bike, leave a solid trail behind you, and avoid every trail, including your own, plus the walls of the arena. Last driver alive wins.

The main menu artwork: a neon light-cycle in a synthwave city — The main menu.

Client and server, four players

One machine runs server.py and owns the truth. It holds the grid, applies every player’s direction change on its own tick, resolves collisions, and broadcasts the resulting state. The clients run client.py: they draw, they send input, and they never decide who died. Players join over the local network, wait together in a lobby until the room fills, and get a colour assigned on connection. Underneath it is a plain TCP socket per player, the same building block I used to wire a Python signal pipeline into Unity on 2D-EMG-GAME.

The waiting-room screen — The lobby, while the room fills up.

The four player light-cycles — The four light-cycles, one per seat in the room.

What it taught me

Sockets, mostly. Also that a render loop and a network loop do not want to run at the same speed. And the rule everything after it depends on: authority lives in exactly one place, and that place is never the client.

Local network only, so not internet-playable. Built with Wu Yedong, Keith Udani and Antoine Martinet. There is a video walkthrough linked from the GitHub README.

Überblick

Mein erstes Netzwerkspiel, unter Linux geschrieben: ein Multiplayer-TRON nach dem Film von 1982. Du fährst dein Lightcycle, lässt eine feste Spur hinter dir und weichst allen Spuren aus, auch deiner eigenen, dazu den Wänden der Arena. Wer zuletzt fährt, gewinnt.

Das Hauptmenü: ein Neon-Lightcycle in einer Synthwave-Stadt — Das Hauptmenü.

Client und Server, vier Spieler

Ein Rechner führt server.py aus und besitzt die Wahrheit. Er hält das Spielfeld, wendet jede Richtungsänderung in seinem eigenen Tick an, löst Kollisionen auf und sendet den resultierenden Zustand. Die Clients führen client.py aus: sie zeichnen, sie senden Eingaben, und sie entscheiden nie, wer gestorben ist. Gespielt wird im lokalen Netz, mit einer Lobby, bis der Raum voll ist, und einer Farbe pro Verbindung. Darunter liegt ein schlichter TCP-Socket pro Spieler, derselbe Baustein, mit dem ich auf 2D-EMG-GAME eine Python-Signalpipeline an Unity angeschlossen habe.

Der Wartebildschirm der Lobby — Die Lobby, während sich der Raum füllt.

Die vier Lightcycles der Spieler — Die vier Lightcycles, eines pro Platz im Raum.

Was ich gelernt habe

Vor allem Sockets. Außerdem, dass eine Render-Schleife und eine Netzwerk-Schleife nicht im selben Takt laufen wollen. Und die Regel, auf der alles Weitere aufbaut: Autorität liegt an genau einer Stelle, und diese Stelle ist nie der Client.

Nur lokales Netz, also nicht über das Internet spielbar. Gebaut mit Wu Yedong, Keith Udani und Antoine Martinet. Ein Video-Walkthrough ist im GitHub-README verlinkt.

Vue d’ensemble

Mon premier jeu en réseau, écrit sous Linux : un TRON multijoueur d’après le film de 1982. Tu pilotes ta moto, tu laisses un mur derrière toi, et tu évites tous les murs, y compris le tien, ainsi que les bords de l’arène. Le dernier pilote en vie gagne.

L'écran-titre : une moto néon dans une ville synthwave — L'écran-titre.

Client et serveur, quatre joueurs

Une machine fait tourner server.py et détient la vérité. Elle garde la grille, applique les changements de direction de chacun sur son propre tick, résout les collisions et diffuse l’état obtenu. Les clients font tourner client.py : ils dessinent, ils envoient les entrées, et ils ne décident jamais qui est mort. Les joueurs rejoignent la partie sur le réseau local, patientent ensemble dans un salon jusqu’à ce que la place soit pleine, et reçoivent une couleur à la connexion. Dessous, il y a une simple socket TCP par joueur, la même brique que celle qui relie un pipeline de signal Python à Unity sur 2D-EMG-GAME.

L'écran du salon d'attente — Le salon, le temps que la partie se remplisse.

Les quatre motos des joueurs — Les quatre motos, une par place dans la partie.

Ce que ça m’a appris

Les sockets, surtout. Et le fait qu’une boucle de rendu et une boucle réseau ne veulent pas tourner à la même vitesse. Enfin la règle dont tout le reste dépend : l’autorité vit à un seul endroit, et cet endroit n’est jamais le client.

Réseau local uniquement, donc pas jouable par Internet. Réalisé avec Wu Yedong, Keith Udani et Antoine Martinet. Une vidéo de démonstration est liée depuis le README GitHub.

概要

Linux 上で書いた初めてのネットワークゲームです。1982年の映画にちなんだマルチプレイ TRON。ライトサイクルを走らせ、後ろに壁を残しながら、自分のものも含めたすべての壁とアリーナの外周を避けます。最後まで生き残った者の勝ちです。

タイトル画面。シンセウェイヴな街並みに置かれたネオンのバイク — タイトル画面。

クライアントとサーバー、4人まで

1台が server.py を実行し、そこが真実を握ります。グリッドを保持し、各プレイヤーの方向転換を自分のティックで適用し、衝突を解決し、その結果の状態を配信します。クライアントは client.py を動かします。描画して入力を送るだけで、誰が死んだかを判断することは決してありません。プレイヤーはローカルネットワークで参加し、部屋が埋まるまでロビーで待ち、接続時に色が割り当てられます。その下にあるのはプレイヤーごとの素朴な TCP ソケットで、2D-EMG-GAME で Python の信号パイプラインを Unity につないだのと同じ部品です。

4台のプレイヤー用ライトサイクル — 4台のライトサイクル。部屋の席ひとつにつき1台です。

ここで学んだこと

まずソケット。それから、描画のループとネットワークのループは同じ速度で回りたがらないということ。そしてその後のすべてが依存する原則、つまり権限はただ一箇所にあり、その一箇所はクライアントではないということです。

ローカルネットワーク専用なので、インターネット越しには遊べません。Wu Yedong、Keith Udani、Antoine Martinet と共同制作。解説動画は GitHub の README からリンクしています。

概览

我的第一个联网游戏，写在 Linux 上：一款取材自 1982 年电影的多人 TRON。骑上光轮摩托，在身后留下实体尾迹，躲开所有尾迹（包括你自己的）以及场地边墙。活到最后的人获胜。

客户端与服务器，四名玩家

一台机器运行 server.py，真相由它掌握。它持有网格，在自己的 tick 上应用每位玩家的转向，判定碰撞，然后把结果状态广播出去。客户端运行 client.py：负责绘制、发送输入，从不自行判断谁死了。玩家通过局域网加入，在大厅里一起等到人满，连接时分配一个颜色。底层是每位玩家一个普通的 TCP 套接字，和我在 2D-EMG-GAME 里把 Python 信号流水线接进 Unity 时用的是同一块积木。

它教会我的

主要是套接字。还有一点：渲染循环和网络循环并不想以同样的速度运转。以及之后一切都依赖的那条规则——权威只能存在于一个地方，而那个地方绝不是客户端。

仅限局域网，无法通过互联网对战。与 Wu Yedong、Keith Udani、Antoine Martinet 共同完成。GitHub README 中有演示视频链接。