Files
claudeandClaude Opus 5.5 2167900e45 M7: Duos and revive
Two-player teams, enforced by the simulation:
- Match puts every player on a team (SimEntity.team); Weapons.damage_player
  refuses damage between teammates from every weapon, the boathook and blasts.
- A player whose health runs out with a teammate standing goes down instead of
  out: 60 health to bleed (one point every half second), crawling at 1 m/s, no
  firing, building, looting or items. Hits still take it; drowning too.
- A standing teammate within 2 m holding interact for 6 s revives them with 30
  health. Letting go or moving away starts it over.
- Downed players are out when their health runs out again or when no teammate
  is left standing, credited to whoever downed them. A team falls together and
  shares its place; the tie-break puts standing ahead of downed.
- Downs and revives go through Match events and the kill feed ("X knocked Y
  down"); the HUD says what to do while down.

Wire: FLAG_DOWNED in the player record and the own block (flags now u16),
so prediction crawls too. Protocol version 5.

Bots: never target a teammate, land with their teammate, regroup when they
stray past 30 m, crawl toward a standing teammate when down, go to revive a
downed teammate within 60 m when not in a fight, and turn from a downed target
to its standing teammate when it's in view.

Options: --team-size=2 on the server, --duos offline, and Solo/Duos under
Crew in the Practice menu. The figure has a downed crawl pose.

Tests: test_duos (downing, crawl, revive, interrupted revive, bleed-out,
finishing, team out, falling together, no friendly damage including kegs,
drowning while down, hash, match placement and tie-break), bots as teammates,
the downed flag on the wire, the feed, server and menu options. make
duo-matches plays 10 bot duos matches.

Closes #30

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 03:01:09 -05:00

231 lines
8.8 KiB
GDScript

## The wire protocol's handshake: message layouts, the protocol version, the reasons a
## server turns a client away, and what to tell the player about each.
##
## Everything is little-endian. The handshake runs on channel 0, reliable:
##
## client -> HELLO u8 type, 4 bytes "TDWL", u16 protocol version, u8 name length,
## name in UTF-8
## server -> WELCOME u8 type, u16 protocol version, u32 handle, u8 tick rate,
## u8 max players, u64 match seed, u8 name length, name as accepted
## server -> REJECT u8 type, u8 reason, u16 the server's protocol version
##
## After a REJECT the server disconnects, with the reason again as the disconnect's
## data, so a client that lost the message still learns why. Decoders return an empty
## Dictionary for anything malformed and never raise an error.
class_name NetProtocol
extends RefCounted
## Raised whenever the wire format changes in a way old clients can't read.
const VERSION: int = 5
const MAGIC: String = "TDWL"
const CHANNEL_CONTROL: int = 0
## Unreliable game traffic: commands up, snapshots down.
const CHANNEL_STATE: int = 1
const CHANNEL_COUNT: int = 2
const MSG_HELLO: int = 1
const MSG_WELCOME: int = 2
const MSG_REJECT: int = 3
## Why a connection ended. Sent in REJECT and as disconnect data.
## ENet's timeout limit for every peer: a reliable message is given up on after this
## many round-trip timeouts' worth of resends (and at least the peer's minimum timeout),
## or after its maximum timeout. ENet's own default. 0, which this once was, gives up as
## soon as any reliable message has waited the minimum timeout: over a link losing 2%
## of datagrams each way, a run of unlucky resends then dropped a few soak clients a
## match (issue N8).
const PEER_TIMEOUT_LIMIT: int = 32
const REASON_NONE: int = 0
const REASON_VERSION: int = 1
const REASON_FULL: int = 2
const REASON_BAD_HELLO: int = 3
const REASON_HANDSHAKE_TIMEOUT: int = 4
const REASON_SHUTDOWN: int = 5
const REASON_KICKED: int = 6
const REASON_LEFT: int = 7
## Client-side only: nothing answered, or the connection went quiet.
const REASON_NO_ANSWER: int = 8
const REASON_LOST: int = 9
## Too many connections from one address in a short time.
const REASON_BUSY: int = 10
const NAME_MAX_CHARS: int = 16
const NAME_MAX_BYTES: int = 64
const DEFAULT_NAME: String = "Castaway"
## No handshake message is longer than this; anything bigger is refused unread.
const MAX_HANDSHAKE_BYTES: int = 96
## A name fit to show: no control or formatting characters, single spaces, at most
## NAME_MAX_CHARS characters, and never empty. Server names use longer limits.
static func clean_name(raw: String, max_chars: int = NAME_MAX_CHARS, max_bytes: int = NAME_MAX_BYTES, fallback: String = DEFAULT_NAME) -> String:
var kept: String = ""
var spaced: bool = true
for index: int in raw.length():
var code: int = raw.unicode_at(index)
var space: bool = code == 0x20 or code == 0x09 or code == 0xA0
# Control characters, bidirectional overrides, zero-width marks and private use.
var hidden: bool = code < 0x20 or (code >= 0x7F and code < 0xA0) \
or (code >= 0x200B and code <= 0x200F) or (code >= 0x202A and code <= 0x202E) \
or (code >= 0x2060 and code <= 0x206F) or code == 0xFEFF or (code >= 0xE000 and code <= 0xF8FF) \
or code == 0xFFFD or code > 0x2FFFF
if space:
if not spaced:
kept += " "
spaced = true
elif not hidden:
kept += String.chr(code)
spaced = false
if kept.length() >= max_chars:
break
kept = kept.strip_edges()
while kept.to_utf8_buffer().size() > max_bytes:
kept = kept.substr(0, kept.length() - 1)
return kept if not kept.is_empty() else fallback
## True for a reason a server sends when it ends a connection, which a client may take
## from the disconnect's data when the REJECT before it was lost or never sent.
static func is_server_reason(reason: int) -> bool:
return (reason > REASON_NONE and reason <= REASON_KICKED) or reason == REASON_BUSY
static func encode_hello(player_name: String, version: int = VERSION) -> PackedByteArray:
var name_bytes: PackedByteArray = clean_name(player_name).to_utf8_buffer()
var out: StreamPeerBuffer = _writer()
out.put_u8(MSG_HELLO)
out.put_data(MAGIC.to_ascii_buffer())
out.put_u16(version)
out.put_u8(name_bytes.size())
out.put_data(name_bytes)
return out.data_array
## {"version", "name"} or an empty Dictionary. The name is returned cleaned.
static func decode_hello(bytes: PackedByteArray) -> Dictionary:
if bytes.size() < 8 or bytes.size() > MAX_HANDSHAKE_BYTES or bytes[0] != MSG_HELLO:
return {}
if bytes.slice(1, 5) != MAGIC.to_ascii_buffer():
return {}
var name_size: int = bytes[7]
if name_size > NAME_MAX_BYTES or bytes.size() != 8 + name_size:
return {}
var player_name: String = _utf8(bytes.slice(8))
if name_size > 0 and player_name.is_empty():
return {}
return {"version": bytes.decode_u16(5), "name": clean_name(player_name)}
static func encode_welcome(handle: int, match_seed: int, max_players: int, player_name: String) -> PackedByteArray:
var name_bytes: PackedByteArray = clean_name(player_name).to_utf8_buffer()
var out: StreamPeerBuffer = _writer()
out.put_u8(MSG_WELCOME)
out.put_u16(VERSION)
out.put_u32(handle)
out.put_u8(Tuning.TICK_RATE_HZ)
out.put_u8(clampi(max_players, 0, 255))
out.put_64(match_seed)
out.put_u8(name_bytes.size())
out.put_data(name_bytes)
return out.data_array
## {"version", "handle", "tick_rate", "max_players", "seed", "name"} or empty.
static func decode_welcome(bytes: PackedByteArray) -> Dictionary:
if bytes.size() < 18 or bytes.size() > MAX_HANDSHAKE_BYTES or bytes[0] != MSG_WELCOME:
return {}
var name_size: int = bytes[17]
if name_size > NAME_MAX_BYTES or bytes.size() != 18 + name_size:
return {}
var handle: int = bytes.decode_u32(3)
if handle <= 0:
return {}
return {
"version": bytes.decode_u16(1), "handle": handle, "tick_rate": bytes[7], "max_players": bytes[8],
"seed": bytes.decode_s64(9), "name": clean_name(_utf8(bytes.slice(18))),
}
static func encode_reject(reason: int) -> PackedByteArray:
var out: StreamPeerBuffer = _writer()
out.put_u8(MSG_REJECT)
out.put_u8(reason)
out.put_u16(VERSION)
return out.data_array
## {"reason", "server_version"} or empty.
static func decode_reject(bytes: PackedByteArray) -> Dictionary:
if bytes.size() != 4 or bytes[0] != MSG_REJECT:
return {}
return {"reason": bytes[1], "server_version": bytes.decode_u16(2)}
## What to tell the player when a connection ends for `reason`. `server_version` is
## the server's protocol version if it said, or 0.
static func reason_text(reason: int, server_version: int = 0, own_version: int = VERSION) -> String:
match reason:
REASON_VERSION:
if server_version > own_version:
return "This server runs a newer version of Tidewall (protocol %d; this game speaks %d). Update the game to join." % [server_version, own_version]
if server_version > 0:
return "This server runs an older version of Tidewall (protocol %d; this game speaks %d). It needs updating before you can join." % [server_version, own_version]
return "This server runs a different version of Tidewall (this game speaks protocol %d)." % own_version
REASON_FULL:
return "The server is full."
REASON_BAD_HELLO:
return "The server didn't understand this game's greeting. It may not be a Tidewall server."
REASON_HANDSHAKE_TIMEOUT:
return "The server gave up waiting for this game to introduce itself."
REASON_SHUTDOWN:
return "The server shut down."
REASON_KICKED:
return "The server removed you from the game."
REASON_LEFT:
return "You left the game."
REASON_BUSY:
return "Too many connections from your address just now. Wait a few seconds and try again."
REASON_NO_ANSWER:
return "No answer from the server. Check the address and port, and that the server is running."
REASON_LOST:
return "The connection to the server was lost."
return "Disconnected."
static func _writer() -> StreamPeerBuffer:
var out: StreamPeerBuffer = StreamPeerBuffer.new()
out.big_endian = false
return out
## Strict UTF-8: an empty string for bytes that aren't valid, with no engine error.
static func _utf8(bytes: PackedByteArray) -> String:
var index: int = 0
while index < bytes.size():
var lead: int = bytes[index]
var extra: int = 0
if lead < 0x80:
extra = 0
elif lead >= 0xC2 and lead < 0xE0:
extra = 1
elif lead >= 0xE0 and lead < 0xF0:
extra = 2
elif lead >= 0xF0 and lead < 0xF5:
extra = 3
else:
return ""
if index + extra > bytes.size() - 1:
return ""
for offset: int in range(1, extra + 1):
if bytes[index + offset] & 0xC0 != 0x80:
return ""
# Overlong forms, surrogates and code points past the end of Unicode.
if extra >= 2:
var second: int = bytes[index + 1]
if (lead == 0xE0 and second < 0xA0) or (lead == 0xED and second >= 0xA0) \
or (lead == 0xF0 and second < 0x90) or (lead == 0xF4 and second >= 0x90):
return ""
index += extra + 1
return bytes.get_string_from_utf8()