Merge worktree-agent-aa7e89ef91d408a4e

This commit is contained in:
Ludovic Marie
2026-10-10 08:46:27 +02:00
3 changed files with 244 additions and 12 deletions
+169
View File
@@ -0,0 +1,169 @@
//! LAN game discovery: LanServerPinger announces a hosted world on the
//! multicast group 224.0.2.60:4445 every 1.5 seconds as
//! `[MOTD]text[/MOTD][AD]port[/AD]`, and LanServerDetection collects those
//! announcements for the multiplayer screen.
use std::{
io,
net::{Ipv4Addr, SocketAddr, SocketAddrV4, UdpSocket},
sync::{
Arc, Mutex,
atomic::{AtomicBool, Ordering},
},
thread::JoinHandle,
time::{Duration, Instant},
};
pub const GROUP: Ipv4Addr = Ipv4Addr::new(224, 0, 2, 60);
pub const PORT: u16 = 4445;
/// LanServerPinger sleeps 1500 ms between announcements.
const INTERVAL: Duration = Duration::from_millis(1500);
/// LanServerDetection.LanServerList drops entries not refreshed for 5 s.
const EXPIRY: Duration = Duration::from_secs(5);
/// LanServerPinger.createPingString.
pub fn ping_string(motd: &str, port: u16) -> String {
format!("[MOTD]{motd}[/MOTD][AD]{port}[/AD]")
}
fn between<'a>(s: &'a str, open: &str, close: &str) -> Option<&'a str> {
let start = s.find(open)? + open.len();
let end = s[start..].find(close)? + start;
Some(&s[start..end])
}
/// LanServerPinger.parseMotd; vanilla shows "missing no" when absent.
pub fn parse_motd(s: &str) -> String {
between(s, "[MOTD]", "[/MOTD]")
.unwrap_or("missing no")
.to_owned()
}
/// LanServerPinger.parseAddress: the announced port, if present and valid.
pub fn parse_port(s: &str) -> Option<u16> {
between(s, "[AD]", "[/AD]")?.parse().ok().filter(|p| *p > 0)
}
/// Announces one hosted world until dropped.
pub struct Pinger {
stop: Arc<AtomicBool>,
thread: Option<JoinHandle<()>>,
}
impl Pinger {
pub fn start(motd: String, port: u16) -> io::Result<Self> {
let socket = UdpSocket::bind(("0.0.0.0", 0))?;
let _ = socket.set_multicast_ttl_v4(4);
let stop = Arc::new(AtomicBool::new(false));
let flag = stop.clone();
let message = ping_string(&motd, port);
let thread = std::thread::Builder::new()
.name("horizon-lan-ping".into())
.spawn(move || {
let target = SocketAddr::V4(SocketAddrV4::new(GROUP, PORT));
while !flag.load(Ordering::Relaxed) {
let _ = socket.send_to(message.as_bytes(), target);
let mut slept = Duration::ZERO;
while slept < INTERVAL && !flag.load(Ordering::Relaxed) {
std::thread::sleep(Duration::from_millis(50));
slept += Duration::from_millis(50);
}
}
})?;
Ok(Self {
stop,
thread: Some(thread),
})
}
}
impl Drop for Pinger {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
if let Some(t) = self.thread.take() {
let _ = t.join();
}
}
}
/// A world announced on the local network.
#[derive(Clone, Debug, PartialEq)]
pub struct LanGame {
pub motd: String,
pub address: String,
}
type Games = Arc<Mutex<Vec<(LanGame, Instant)>>>;
/// Listens for announcements until the last clone is dropped.
#[derive(Clone, Debug)]
pub struct Scanner {
inner: Arc<ScanInner>,
}
#[derive(Debug)]
struct ScanInner {
games: Games,
stop: Arc<AtomicBool>,
}
impl Drop for ScanInner {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
}
}
impl Scanner {
/// Bind the discovery port; without it the list simply stays empty.
pub fn start() -> Self {
let games: Games = Arc::default();
let stop = Arc::new(AtomicBool::new(false));
if let Ok(socket) = bind_listener() {
let (games, stop) = (games.clone(), stop.clone());
let _ = std::thread::Builder::new()
.name("horizon-lan-scan".into())
.spawn(move || listen(socket, games, stop));
}
Self {
inner: Arc::new(ScanInner { games, stop }),
}
}
/// The live announcements, oldest first.
pub fn games(&self) -> Vec<LanGame> {
let mut games = self.inner.games.lock().unwrap();
games.retain(|(_, seen)| seen.elapsed() < EXPIRY);
games.iter().map(|(g, _)| g.clone()).collect()
}
}
fn bind_listener() -> io::Result<UdpSocket> {
let socket = UdpSocket::bind(("0.0.0.0", PORT))?;
socket.join_multicast_v4(&GROUP, &Ipv4Addr::UNSPECIFIED)?;
socket.set_read_timeout(Some(Duration::from_millis(250)))?;
Ok(socket)
}
fn listen(socket: UdpSocket, games: Games, stop: Arc<AtomicBool>) {
let mut buf = [0u8; 1024];
while !stop.load(Ordering::Relaxed) {
let Ok((n, from)) = socket.recv_from(&mut buf) else {
continue;
};
let text = String::from_utf8_lossy(&buf[..n]);
let Some(port) = parse_port(&text) else {
continue;
};
let game = LanGame {
motd: parse_motd(&text),
address: format!("{}:{port}", from.ip()),
};
let mut games = games.lock().unwrap();
match games.iter_mut().find(|(g, _)| g.address == game.address) {
Some(entry) => *entry = (game, Instant::now()),
None => games.push((game, Instant::now())),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn ping_string_round_trips() {
let s = ping_string("Steve - World", 25565);
assert_eq!(s, "[MOTD]Steve - World[/MOTD][AD]25565[/AD]");
assert_eq!(parse_motd(&s), "Steve - World");
assert_eq!(parse_port(&s), Some(25565));
assert_eq!(parse_port("[AD]0[/AD]"), None);
assert_eq!(parse_motd("junk"), "missing no");
}
}
+6
View File
@@ -8,6 +8,7 @@ pub mod chunks;
pub mod conn;
pub mod containers;
pub mod data;
pub mod discovery;
pub mod entity;
pub mod guest;
pub mod hub;
@@ -111,6 +112,8 @@ pub struct Lan {
events: Receiver<NetEvent>,
pub port: u16,
listener: Option<JoinHandle<()>>,
/// The multicast announcement (LanServerPinger); absent when the socket failed.
_pinger: Option<discovery::Pinger>,
}
impl Lan {
/// Listen on `port` (0 picks a free one).
@@ -123,6 +126,7 @@ impl Lan {
let listener = TcpListener::bind(("0.0.0.0", port))?;
listener.set_nonblocking(true)?;
let port = listener.local_addr()?.port();
let _pinger = discovery::Pinger::start(motd.clone(), port).ok();
let (tx, events) = channel();
let shared = Arc::new(Shared {
sync,
@@ -142,6 +146,7 @@ impl Lan {
events,
port,
listener: Some(listener),
_pinger,
})
}
/// Everything the connection threads reported since the last call.
@@ -160,6 +165,7 @@ impl Lan {
if let Some(t) = self.listener.take() {
let _ = t.join();
}
self._pinger = None;
}
}
impl Drop for Lan {
+69 -12
View File
@@ -3,6 +3,7 @@
//! Disconnected screen. Entries are pinged in the background like
//! ServerStatusPinger to show the MOTD, player count and latency.
use crate::hud::{HudAtlas, HudBatch, rgba};
use crate::lan::discovery::Scanner;
use horizon_protocol::servers::{self, ServerEntry};
use std::{
collections::HashMap,
@@ -31,6 +32,8 @@ pub enum Screen {
servers: Vec<ServerEntry>,
selected: Option<usize>,
pings: Pings,
/// Worlds announced on the local network, listed after the servers.
lan: Scanner,
},
/// Add (index None) or edit a server entry.
Edit {
@@ -92,6 +95,18 @@ fn ping_all(servers: &[ServerEntry], pings: &Pings) {
}
}
/// The address of list row `index`: the saved servers, then the LAN games.
fn entry_address(servers: &[ServerEntry], lan: &Scanner, index: usize) -> Option<String> {
match servers.get(index) {
Some(s) => Some(s.ip.clone()),
None => lan
.games()
.into_iter()
.nth(index - servers.len())
.map(|g| g.address),
}
}
impl Screen {
pub fn list(saves: &Path) -> Self {
let servers = servers::load(&servers_file(saves));
@@ -101,6 +116,7 @@ impl Screen {
servers,
selected: None,
pings,
lan: Scanner::start(),
}
}
pub fn buttons(&self, w: f32, h: f32) -> Vec<ButtonSpec> {
@@ -256,6 +272,7 @@ impl Screen {
servers,
selected,
pings,
lan,
} => {
centered(batch, "Play Multiplayer", 8.0, u32::MAX);
batch.fill(atlas, 0.0, 32.0, w, h - 32.0 - 64.0, rgba(0, 0, 0, 100));
@@ -319,6 +336,42 @@ impl Screen {
);
}
}
for (k, game) in lan.games().iter().enumerate() {
let i = servers.len() + k;
let y = 36.0 + i as f32 * 36.0;
if y + 36.0 > h - 64.0 {
break;
}
let x = w / 2.0 - 152.0;
if *selected == Some(i) {
batch.fill(
atlas,
x - 2.0,
y - 2.0,
306.0,
36.0,
rgba(128, 128, 128, 255),
);
batch.fill(atlas, x - 1.0, y - 1.0, 304.0, 34.0, rgba(0, 0, 0, 255));
}
batch.text(atlas, "LAN World", x + 35.0, y + 1.0, u32::MAX, false);
batch.text(
atlas,
&game.motd,
x + 35.0,
y + 12.0,
rgba(128, 128, 128, 255),
false,
);
batch.text(
atlas,
&game.address,
x + 35.0,
y + 22.0,
rgba(96, 96, 96, 255),
false,
);
}
if servers.is_empty() {
centered(
batch,
@@ -392,12 +445,15 @@ impl Screen {
match (&mut *self, id) {
(
Self::List {
servers, selected, ..
servers,
selected,
lan,
..
},
Some(40),
) => {
if let Some(s) = selected.and_then(|i| servers.get(i)) {
return Outcome::Connect(s.ip.clone());
if let Some(address) = selected.and_then(|i| entry_address(servers, lan, i)) {
return Outcome::Connect(address);
}
}
(Self::List { .. }, Some(41)) => {
@@ -446,21 +502,22 @@ impl Screen {
(Self::List { .. }, Some(46)) => return Outcome::Back,
(
Self::List {
servers, selected, ..
servers,
selected,
lan,
..
},
None,
) => {
let index = ((y - 36.0) / 36.0).floor();
if y >= 36.0
&& y < h - 64.0
&& (x - w / 2.0).abs() < 154.0
&& (index as usize) < servers.len()
{
if y >= 36.0 && y < h - 64.0 && (x - w / 2.0).abs() < 154.0 {
let index = index as usize;
if *selected == Some(index) {
return Outcome::Connect(servers[index].ip.clone());
if let Some(address) = entry_address(servers, lan, index) {
if *selected == Some(index) {
return Outcome::Connect(address);
}
*selected = Some(index);
}
*selected = Some(index);
}
}
(