diff --git a/crates/horizon-client/src/front.rs b/crates/horizon-client/src/front.rs index 75e6547e1..1fa91f6cf 100644 --- a/crates/horizon-client/src/front.rs +++ b/crates/horizon-client/src/front.rs @@ -455,7 +455,7 @@ impl Title { _ => 50, }), FIELD_A | FIELD_B => { - if let Screen::Edit { focus, .. } = screen { + if let Screen::Edit { focus, .. } | Screen::Friend { focus, .. } = screen { *focus = u8::from(hit == FIELD_B); } None @@ -488,6 +488,25 @@ impl Title { } } +/// The end of `text` that fits `width`, led by an ellipsis when cut. +fn tail_fit(ui: &Ui, text: &str, width: f32) -> String { + if ui.measure(Face::Regular, BODY, text) <= width { + return text.to_owned(); + } + let chars: Vec = text.chars().collect(); + let mut start = 0; + while start < chars.len() { + let tail: String = std::iter::once('…') + .chain(chars[start..].iter().copied()) + .collect(); + if ui.measure(Face::Regular, BODY, &tail) <= width { + return tail; + } + start += 1; + } + String::new() +} + /// The page header plus a row of actions under it; returns the y below. fn header(ui: &mut Ui, x: f32, title: &str, description: &str) -> f32 { let y = 36.0; @@ -960,15 +979,15 @@ fn multiplayer_page(ui: &mut Ui, x: f32, w: f32, screen: &Screen, caret: bool) { ); ui.divider(x, y + rh, w); } - Screen::Friend { code } => { + Screen::Friend { code, relay, focus } => { let y = header( ui, x, "Join a friend", "Paste the invite code your friend sees in their pause menu.", ); - let available = horizon_friends::relay_url().is_some(); - let ok = available && horizon_friends::Code::parse(code).is_some(); + let parsed = horizon_friends::invite::parse_detailed(code); + let ok = parsed.is_ok(); actions_right( ui, x + w, @@ -980,26 +999,45 @@ fn multiplayer_page(ui: &mut Ui, x: f32, w: f32, screen: &Screen, caret: bool) { ); ui.divider(x, y, w); let rh = 12.0 + CONTROL + 12.0; - ui.text_line(Face::Regular, BODY, rh, x, y, color::MUTED, "Invite code"); let fx = x + t::ROW_LABEL + 16.0; - ui.field( - FIELD_A, - [fx, y + 12.0, (w - t::ROW_LABEL - 16.0).min(240.0), CONTROL], - code, - "K7QM-3XPD", - true, - caret, - ); - ui.divider(x, y + rh, w); - if !available { - ui.text( - Face::Regular, - SMALL, - x, - y + rh + 12.0, - color::FAINT, - "Joining friends isn't available yet in this build.", + let fw = w - t::ROW_LABEL - 16.0; + let rows = [ + (FIELD_A, "Invite code", code, "Paste the code here", fw), + ( + FIELD_B, + "Relay (optional)", + relay, + "host:port, for short codes", + fw.min(360.0), + ), + ]; + let mut ry = y; + for (i, (fid, label, value, hint, width)) in rows.into_iter().enumerate() { + ui.text_line(Face::Regular, BODY, rh, x, ry, color::MUTED, label); + // A long code shows its end, where the typing is. + let shown = tail_fit(ui, value, width - 28.0); + ui.field( + fid, + [fx, ry + 12.0, width, CONTROL], + &shown, + hint, + usize::from(*focus) == i, + caret, ); + ry += rh; + ui.divider(x, ry, w); + } + let note = match parsed { + _ if code.trim().is_empty() => None, + Err(e) => Some(e.to_string()), + Ok(horizon_friends::invite::Parsed::Short(_)) if relay.trim().is_empty() => Some( + "This is a relay's short code: fill in your friend's relay above, or ask for the full code." + .to_owned(), + ), + Ok(_) => None, + }; + if let Some(note) = note { + ui.text(Face::Regular, SMALL, x, ry + 12.0, color::MUTED, ¬e); } } Screen::Disconnected { reason, retry } => { diff --git a/crates/horizon-client/src/game/friends.rs b/crates/horizon-client/src/game/friends.rs index 90e5b82a2..51dfe3fbf 100644 --- a/crates/horizon-client/src/game/friends.rs +++ b/crates/horizon-client/src/game/friends.rs @@ -30,15 +30,6 @@ pub const HELP: &[&str] = &[ "friends status the code, how friends reach this host, the guests", ]; -/// The relay the player set (Join a friend's Relay field, `friendsRelay` -/// in horizon.txt), else `HORIZON_RELAY_URL`. None by default. -pub(super) fn relay_setting() -> Option { - let dir = std::env::current_dir().ok()?; - horizon_client::ui_theme::preference(&dir, "friendsRelay") - .filter(|r| !r.is_empty()) - .or_else(horizon_friends::relay_url) -} - /// `HORIZON_STUN_SERVERS`, else `friendsStun` in horizon.txt, else the defaults. fn stun_servers() -> Vec { if std::env::var_os("HORIZON_STUN_SERVERS").is_some() { @@ -78,7 +69,7 @@ impl Game<'_> { lan: std::net::SocketAddr::from(([127, 0, 0, 1], port)), protocol: PROTOCOL_VERSION, game: GAME_VERSION.to_owned(), - relay: relay_setting(), + relay: horizon_client::net::friends_relay_setting(), path: PathMode::from_env(), port: std::env::var("HORIZON_FRIENDS_PORT") .ok() diff --git a/crates/horizon-client/src/multiplayer.rs b/crates/horizon-client/src/multiplayer.rs index 0c4019568..a94972146 100644 --- a/crates/horizon-client/src/multiplayer.rs +++ b/crates/horizon-client/src/multiplayer.rs @@ -49,6 +49,9 @@ pub enum Screen { /// from Horizon's multiplayer page). Friend { code: String, + /// The relay for short codes (optional; saved on Join). + relay: String, + focus: u8, }, Disconnected { reason: String, @@ -212,18 +215,18 @@ impl Screen { 53, ), ], - Self::Friend { code } => vec![ + Self::Friend { code, .. } => vec![ b( w / 2.0 - 100.0, - h / 4.0 + 96.0 + 12.0, + h / 4.0 + 96.0 + 18.0, 200.0, "Join", - horizon_friends::Code::parse(code).is_some(), + horizon_friends::invite::parse(code).is_some(), 56, ), b( w / 2.0 - 100.0, - h / 4.0 + 120.0 + 12.0, + h / 4.0 + 120.0 + 18.0, 200.0, "Cancel", true, @@ -465,9 +468,18 @@ impl Screen { blink, ); } - Self::Friend { code } => { + Self::Friend { code, relay, focus } => { centered(batch, "Join a Friend", 20.0, u32::MAX); - Self::field(atlas, batch, "Invite Code", code, 100.0 - 11.0, true, blink); + Self::field(atlas, batch, "Invite Code", code, 53.0, *focus == 0, blink); + Self::field( + atlas, + batch, + "Relay (optional)", + relay, + 94.0, + *focus == 1, + blink, + ); } Self::Disconnected { reason, retry } => { centered( @@ -514,11 +526,7 @@ impl Screen { address: String::new(), } } - (Self::List { .. }, Some(47)) => { - *self = Self::Friend { - code: String::new(), - } - } + (Self::List { .. }, Some(47)) => *self = Self::friend(), (Self::List { .. }, Some(42)) => { *self = Self::Edit { index: None, @@ -610,12 +618,14 @@ impl Screen { (Self::Direct { address }, Some(52)) => { return Outcome::Connect(address.trim().to_owned()); } - (Self::Friend { code }, Some(56)) => { - if let Some(code) = horizon_friends::Code::parse(code) { + (Self::Friend { code, relay, .. }, Some(56)) => { + if horizon_friends::invite::parse(code).is_some() { + crate::net::save_friends_relay(relay.trim()); + let code: String = code.chars().filter(|c| !c.is_whitespace()).collect(); return Outcome::Connect(format!("{}{code}", crate::net::FRIEND)); } } - (Self::Edit { focus, .. }, None) => { + (Self::Edit { focus, .. } | Self::Friend { focus, .. }, None) => { for (i, fy) in [(0u8, 53.0 + 11.0), (1, 94.0 + 11.0)] { if y >= fy && y < fy + 20.0 && (x - w / 2.0).abs() < 100.0 { *focus = i; @@ -635,10 +645,20 @@ impl Screen { .. } => Some(if *focus == 0 { name } else { address }), Self::Direct { address } => Some(address), - Self::Friend { code } => Some(code), + Self::Friend { + code, relay, focus, .. + } => Some(if *focus == 0 { code } else { relay }), _ => None, } } + /// Join a friend, with the relay the player set before. + pub fn friend() -> Self { + Self::Friend { + code: String::new(), + relay: crate::net::friends_relay_setting().unwrap_or_default(), + focus: 0, + } + } /// Auto-reconnect's attempt, once its countdown is over. pub fn due_retry(&mut self) -> Option { let Self::Disconnected { retry, .. } = self else { @@ -655,15 +675,26 @@ impl Screen { Self::Edit { focus: 0, .. } => ("server.name", 0), Self::Edit { .. } => ("server.address", 0), Self::Direct { .. } => ("server.direct", 0), - Self::Friend { .. } => ("friend.code", 0), + Self::Friend { focus: 0, .. } => ("friend.code", 0), + Self::Friend { .. } => ("friend.relay", 0), _ => return None, }; - self.focused_field().map(|f| (id, f, 128)) + let max = self.max_length(); + self.focused_field().map(|f| (id, f, max)) + } + /// Invite codes with IPv6 and a relay run past a server address's 128. + fn max_length(&self) -> usize { + if matches!(self, Self::Friend { .. }) { + 256 + } else { + 128 + } } pub fn type_text(&mut self, text: &str) { + let max = self.max_length(); if let Some(field) = self.focused_field() { for c in text.chars().filter(|c| !c.is_control()) { - if field.chars().count() < 128 { + if field.chars().count() < max { field.push(c); } } @@ -675,7 +706,7 @@ impl Screen { } } pub fn tab(&mut self) { - if let Self::Edit { focus, .. } = self { + if let Self::Edit { focus, .. } | Self::Friend { focus, .. } = self { *focus = (*focus + 1) % 2; } } diff --git a/crates/horizon-client/src/net.rs b/crates/horizon-client/src/net.rs index 8af10f66a..047698e14 100644 --- a/crates/horizon-client/src/net.rs +++ b/crates/horizon-client/src/net.rs @@ -150,32 +150,46 @@ impl Drop for Session { /// client reaches on a loopback port, so everything after is a plain join. pub const FRIEND: &str = horizon_friends::ADDRESS_PREFIX; -/// An address as players and logs see it: a friend's invite code without -/// its secret half. +/// An address as players and logs see it: a friend's invite code stays +/// out of it (its secret is in there). pub fn shown_address(address: &str) -> String { match address.strip_prefix(FRIEND) { - Some(code) => match horizon_friends::Code::parse(code) { - Some(code) => format!("Friend's world ({}-****)", code.nameplate), - None => "Friend's world".to_owned(), + Some(code) => match horizon_friends::invite::parse(code) { + Some(horizon_friends::invite::Parsed::Short(c)) => { + format!("Friend's world ({}-****)", c.nameplate) + } + _ => "Friend's world".to_owned(), }, None => address.to_owned(), } } -/// Find the friend's world behind the code and open the tunnel: the loopback -/// address to connect to. +/// The relay the player set (`friendsRelay` in horizon.txt, beside +/// options.txt), else `HORIZON_RELAY_URL`. None by default. +pub fn friends_relay_setting() -> Option { + let dir = std::env::current_dir().ok()?; + crate::ui_theme::preference(&dir, "friendsRelay") + .filter(|r| !r.is_empty()) + .or_else(horizon_friends::relay_url) +} +/// Remember the relay typed on Join a friend (empty forgets it). +pub fn save_friends_relay(relay: &str) { + if let Ok(dir) = std::env::current_dir() { + crate::ui_theme::set_preference(&dir, "friendsRelay", (!relay.is_empty()).then_some(relay)); + } +} + +/// Reach the friend's world from the code (directly, or through a relay) +/// and open the tunnel: the loopback address to connect to. fn join_friend(code: &str, send: &Sender) -> Result<(String, u16), String> { use horizon_friends::{ - Code, JoinError, PathMode, + PathMode, guest::{self, GuestConfig}, }; - let code = Code::parse(code) - .ok_or("That isn't an invite code: codes are eight letters and digits, like K7QM-3XPD.")?; - let relay = horizon_friends::relay_url().ok_or_else(|| JoinError::NotAvailable.to_string())?; status(send, "Finding your friend's world..."); let tunnel = guest::join(&GuestConfig { - relay, - code, + code: code.to_owned(), + relay: friends_relay_setting(), protocol: PROTOCOL_VERSION, game: horizon_protocol::GAME_VERSION.to_owned(), path: PathMode::from_env(), diff --git a/launcher/src/backend.rs b/launcher/src/backend.rs index 08c679a88..00c0db163 100644 --- a/launcher/src/backend.rs +++ b/launcher/src/backend.rs @@ -1057,8 +1057,8 @@ pub fn client(tag: &str) -> Result { /// Start the game straight into a friend's world: `--server friend:CODE`. pub fn join_friend(cmd: &mut Command, code: &str) -> Result<(), String> { - let code = horizon_friends::Code::parse(code) - .ok_or("That isn't an invite code: codes are eight letters and digits, like K7QM-3XPD.")?; + horizon_friends::invite::parse_detailed(code).map_err(|e| e.to_string())?; + let code: String = code.chars().filter(|c| !c.is_whitespace()).collect(); cmd.arg("--server") .arg(format!("{}{code}", horizon_friends::ADDRESS_PREFIX)); Ok(()) diff --git a/launcher/src/main.rs b/launcher/src/main.rs index 6ee37b95c..0a6d5b453 100644 --- a/launcher/src/main.rs +++ b/launcher/src/main.rs @@ -2228,7 +2228,8 @@ impl Launcher { } fn join_friend(&mut self) { - if self.mode != Mode::Client || horizon_friends::invite::parse(&self.friend_code).is_none() { + if self.mode != Mode::Client || horizon_friends::invite::parse(&self.friend_code).is_none() + { return; } self.joining = Some(self.friend_code.clone()); diff --git a/tools/test_friends.py b/tools/test_friends.py index 97ef7a41c..086516a72 100644 --- a/tools/test_friends.py +++ b/tools/test_friends.py @@ -1,22 +1,24 @@ #!/usr/bin/env python3 """Play with friends end to end, without the internet. -A relay (`horizon-relay`) on a free local port; a host Horizon that opens a -world and shares it behind an invite code (`friends host`); a guest Horizon -that joins with the code (`connect friend:CODE`). The guest joins twice: -first on the direct path, then started with HORIZON_FRIENDS_PATH=relay so -the session goes through the relay. Each time both sides must see the -other's chat line, the other moving, a block the host places and the block -the guest breaks; the host's counts say which path each session took, and -the relay's relayed bytes must stay small for the direct session and grow -with the relayed one. Last, the host stops sharing and a guest using the -old code is told the invite has ended. +(a) The code alone: a host Horizon opens a world and shares it (`friends +host`) with no relay anywhere; a guest Horizon joins with the full invite +code (`connect friend:CODE`) by dialling the endpoints in it. (b) A +self-hosted relay run locally (`horizon-relay`): the host also gets a short +code from it, and a guest started with HORIZON_FRIENDS_PATH=relay joins with +the short code through it. Each time both sides must see the other's chat +line, the other moving, a block the host places and the block the guest +breaks; then the host stops sharing and a guest with the old code is told +why it can't join. `--baseline` first runs the same checks over plain LAN. +The router is never asked to open a port (HORIZON_FRIENDS_UPNP=0) and STUN +is off: nothing leaves the machine. python3 tools/test_friends.py --client target/fast/horizon-client --relay target/fast/horizon-relay -`--relay-url HOST:PORT` uses a relay already running elsewhere (two -machines); `--role host|guest` then runs one side only and prints or takes -the code (`--code`). Needs a display on Linux (xvfb-run -a). +`--role host|guest` runs one side only (two machines, e.g. over a tailnet): +the host prints the code, the guest takes it with `--code` (`--relay-url` +for a relay elsewhere, `--path relay` to force it). Needs a display on Linux +(xvfb-run -a). """ import argparse import json @@ -112,7 +114,6 @@ class Game: def host_world(host): host('open Friends 0 creative') host.wait('status', lambda v: v['player'] is not None and v['pending_chunks'] == 0, 120, 'host world') - assert host('friends status')['available'], 'HORIZON_RELAY_URL did not reach the host' host('friends host') return host.wait('friends status', lambda v: v['code'], 30, 'invite code')['code'] @@ -182,13 +183,45 @@ def leave(host, guest, name): host.wait('lan status', lambda v: all(g['name'] != name for g in v['guests']), 30, 'the guest leaving') -def full(args, work, relay_url): - env = {'HORIZON_RELAY_URL': relay_url} +def start_relay(args, work): + """A relay on a free local port, as anyone would run their own.""" + port = free_port() + url = f'127.0.0.1:{port}' + log = (work / 'relay.log').open('w+') + process = subprocess.Popen([str(args.relay.resolve())], env=dict(os.environ, PORT=str(port)), + stdout=log, stderr=subprocess.STDOUT) + deadline = time.monotonic() + 10 + while True: + try: + health(url) + return process, log, url + except OSError: + assert time.monotonic() < deadline, 'the relay did not start' + time.sleep(0.1) + + +def set_relay(game, url): + """What typing the relay on Join a friend saves (horizon.txt).""" + path = game.home / 'horizon.txt' + lines = [l for l in (path.read_text().splitlines() if path.exists() else []) if not l.startswith('friendsRelay:')] + path.write_text('\n'.join(lines + [f'friendsRelay:{url}']) + '\n') + + +def full(args, work): + # Tests never touch the real router or ask the internet. Both games run on + # this machine, so the code also holds 127.0.0.1 (a firewall such as + # macOS's may hold back connections to the LAN address from an unsigned + # binary started over SSH, which can't show its prompt). + env = {'HORIZON_FRIENDS_UPNP': '0', 'HORIZON_STUN_SERVERS': 'none', 'HORIZON_FRIENDS_LOOPBACK': '1'} host = Game(args.client, args.resources, work, 'host', env) games = [host] + relay = None try: + # (a) The code alone: no relay anywhere. code = host_world(host) - print(f'host shares the world: {code[:4]}-****') + status = host('friends status') + assert status['short'] is None and len(code) > 30, status + print(f'host shares the world: a {len(code.replace("-", ""))}-symbol code, no relay; {status["summary"]}') if args.baseline: # The same checks over plain LAN, without the tunnel: the behaviour # the tunnel must reproduce. @@ -199,42 +232,47 @@ def full(args, work, relay_url): print('plain LAN: chat, movement and blocks both ways') leave(host, guest, 'Plain') guest.stop() - # Direct path. - guest = Game(args.client, args.resources, work, 'guest-direct', env) + guest = Game(args.client, args.resources, work, 'guest-code', env) games.append(guest) - before = health(relay_url)['relayed_bytes'] join(guest, code, 'Guest') play_together(host, guest, 'Guest', 1) - direct_bytes = health(relay_url)['relayed_bytes'] - before assert host('friends status')['direct'] == 1, host('friends status') - assert direct_bytes < 64 * 1024, f'the direct session went through the relay ({direct_bytes} bytes)' - print(f'direct path: chat, movement and blocks both ways; relay carried {direct_bytes} bytes') + print('code alone: chat, movement and blocks both ways, no server involved') leave(host, guest, 'Guest') + host('friends stop') + assert host('friends status')['code'] is None + assert host('lan status') == {'open': False}, 'sharing opened LAN, so stopping closes it' + join(guest, code, 'Late') + reason = guest.wait('screen', lambda v: v['menu']['disconnected'], 30, 'the ended code')['menu']['disconnected'] + assert "Couldn't reach your friend's game" in reason, reason + print(f'after stopping: "{reason}"') guest.stop() - # Forced relay path. - guest = Game(args.client, args.resources, work, 'guest-relay', - dict(env, HORIZON_FRIENDS_PATH='relay')) + # (b) A self-hosted relay, run locally: the short code, relayed. + relay, relay_log, relay_url = start_relay(args, work) + set_relay(host, relay_url) + host('friends host') + status = host.wait('friends status', lambda v: v['short'], 30, 'the short code') + short = status['short'] + guest = Game(args.client, args.resources, work, 'guest-relay', dict(env, HORIZON_FRIENDS_PATH='relay')) games.append(guest) + set_relay(guest, relay_url) before = health(relay_url)['relayed_bytes'] - join(guest, code, 'Relayed') + join(guest, short, 'Relayed') play_together(host, guest, 'Relayed', 2) relayed_bytes = health(relay_url)['relayed_bytes'] - before status = host('friends status') assert status['relayed'] == 1, status # Render distance 2: the join is some tens of kB of compressed chunks. - assert relayed_bytes > max(32 * 1024, 4 * direct_bytes), \ - f'the relayed session carried only {relayed_bytes} bytes (direct: {direct_bytes})' - print(f'relay path: chat, movement and blocks both ways; relay carried {relayed_bytes} bytes') + assert relayed_bytes > 32 * 1024, f'the relayed session carried only {relayed_bytes} bytes' + print(f'self-hosted relay, short code {short[:4]}-****: chat, movement and blocks both ways; ' + f'relay carried {relayed_bytes} bytes') leave(host, guest, 'Relayed') - # The code ends with sharing. host('friends stop') - assert host('friends status')['code'] is None - join(guest, code, 'Late') + join(guest, short, 'Late') reason = guest.wait('screen', lambda v: v['menu']['disconnected'], 30, 'the ended invite')['menu']['disconnected'] assert 'invite has ended' in reason, reason print(f'after stopping: "{reason}"') - assert host('lan status') == {'open': False}, 'sharing opened LAN, so stopping closes it' - return code + return code + short except Exception: for g in games: print(f'--- {g.home.name} log tail ---') @@ -243,10 +281,21 @@ def full(args, work, relay_url): finally: for g in games: g.stop() + if relay: + relay.terminate() + relay.wait(timeout=10) + relay_log.seek(0) + text = relay_log.read() + print(f'relay log: {text.splitlines()}') + # Counts only: no code, no address, no name. + for secret in ['127.0.0.1', 'Guest', 'Relayed', 'Late']: + assert secret not in text, f'the relay logged {secret!r}' def one_side(args, work): - env = {'HORIZON_RELAY_URL': args.relay_url} + env = {'HORIZON_FRIENDS_UPNP': '0', 'HORIZON_STUN_SERVERS': 'none'} + if args.relay_url: + env['HORIZON_RELAY_URL'] = args.relay_url if args.path: env['HORIZON_FRIENDS_PATH'] = args.path game = Game(args.client, args.resources, work, args.role, env) @@ -276,7 +325,7 @@ def main(): parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument('--client', type=Path, required=True) parser.add_argument('--relay', type=Path, help='horizon-relay binary (started on a free local port)') - parser.add_argument('--relay-url', help='an already running relay, HOST:PORT') + parser.add_argument('--relay-url', help='--role: a relay already running elsewhere, HOST:PORT') parser.add_argument('--resources', type=Path, default=ROOT / '.local/horizon-client/26.3') parser.add_argument('--role', choices=['host', 'guest']) parser.add_argument('--code') @@ -290,39 +339,10 @@ def main(): with tempfile.TemporaryDirectory(prefix='hzf-', dir='/tmp') as directory: work = Path(directory) if args.role: - assert args.relay_url, '--role needs --relay-url' return one_side(args, work) - relay = None - relay_url = args.relay_url - if not relay_url: - assert args.relay, 'give --relay or --relay-url' - port = free_port() - relay_url = f'127.0.0.1:{port}' - relay_log = (work / 'relay.log').open('w+') - relay = subprocess.Popen([str(args.relay.resolve())], env=dict(os.environ, PORT=str(port)), - stdout=relay_log, stderr=subprocess.STDOUT) - deadline = time.monotonic() + 10 - while True: - try: - health(relay_url) - break - except OSError: - assert time.monotonic() < deadline, 'the relay did not start' - time.sleep(0.1) - try: - code = full(args, work, relay_url) - finally: - if relay: - relay.terminate() - relay.wait(timeout=10) - relay_log.seek(0) - text = relay_log.read() - print(f'relay log: {text.splitlines()}') - if relay: - # Counts only: no code, no address, no name. - for secret in [code[:4], '127.0.0.1', 'Guest', 'Relayed']: - assert secret not in text, f'the relay logged {secret!r}' - print('Play with friends passed: direct and relayed sessions, chat, movement and blocks both ways') + assert args.relay, 'give --relay (the relay binary, run locally for the relay half)' + full(args, work) + print('Play with friends passed: the code alone and a self-hosted relay; chat, movement and blocks both ways') if __name__ == '__main__':