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>
288 lines
10 KiB
GDScript
288 lines
10 KiB
GDScript
## Command-line configuration for a headless server.
|
|
##
|
|
## tools/godot.sh -- --server [--listen] [--port=N] [--seed=N] [--players=N] [--bots=N]
|
|
## [--bot-difficulty=mixed|easy|normal|hard] [--team-size=1|2] [--ticks=N]
|
|
## [--unthrottled] [--log-every=N] [--matches=N] [--world-hash-every=N]
|
|
## [--name=NAME] [--list=HOST[:PORT]]... [--no-lan]
|
|
## [--health-port=N] [--health-bind=ADDRESS] [--stop-file=PATH]
|
|
## [--config=PATH]
|
|
##
|
|
## `--config` reads options from a file, one per line, written without the leading
|
|
## dashes: `port = 24650`, or a bare `listen` for a switch. Blank lines and lines
|
|
## starting with # are skipped. Options after `--config` on the command line win.
|
|
## See packaging/server/server.cfg.
|
|
##
|
|
## `--health-port` answers `GET /health` over HTTP on that TCP port (HealthServer), on
|
|
## `--health-bind`, loopback by default. `--stop-file` makes the server stop cleanly,
|
|
## telling everyone connected, as soon as that file exists: the packaging's wrapper
|
|
## creates it on SIGTERM, which the engine itself can't catch.
|
|
##
|
|
## With `--listen` the server takes network players on UDP `--port`, waits in the lobby
|
|
## for the first of them, and with any `--bots` above 0 fills each match's empty places
|
|
## with bots. Without it the match starts at once with `--players` idle slots.
|
|
##
|
|
## A listening server answers LAN discovery on its port plus one unless `--no-lan`,
|
|
## and registers with each `--list` server (see ListServer) under `--name`.
|
|
##
|
|
## `--team-size=2` plays duos (M7): pairs in join order, who can't hurt each other and
|
|
## go down instead of out while their teammate stands. 1, solo, is the default.
|
|
##
|
|
## Unknown or malformed arguments are errors, so a typo can't silently run the wrong
|
|
## match. See `parse()`.
|
|
class_name ServerConfig
|
|
extends RefCounted
|
|
|
|
const DEFAULT_PORT: int = 24650
|
|
## The `--fault` names `HeadlessServer` understands. They exist so tools/smoke.sh can
|
|
## prove a script error really produces a non-zero exit.
|
|
const FAULTS: Array[String] = ["", "script-error"]
|
|
|
|
## True when `--server` was given.
|
|
var server: bool = false
|
|
## The match seed. `has_seed` is false when none was given and the server must pick one.
|
|
var match_seed: int = 0
|
|
var has_seed: bool = false
|
|
## True when `--listen` was given: take network players on `port`.
|
|
var listen: bool = false
|
|
## UDP port a listening server uses.
|
|
var port: int = DEFAULT_PORT
|
|
## Idle player slots, for a server that isn't listening.
|
|
var players: int = 0
|
|
var bots: int = 0
|
|
## Players on a team: 1 for solo, Tuning.DUO_TEAM_SIZE for duos.
|
|
var team_size: int = 1
|
|
## Every bot's difficulty, as an index into Tuning.BOT_DIFFICULTIES, or -1 to mix them.
|
|
var bot_difficulty: int = -1
|
|
## Ticks to run before exiting. 0 runs until the process is stopped.
|
|
var ticks: int = 0
|
|
## Stops after this many matches have ended. 0 doesn't stop for matches.
|
|
var matches: int = 0
|
|
## On the simulation ticks from each multiple of this many up to the snapshot interval
|
|
## (never tick 0, which lasts the whole lobby), logs NetWorld.world_hash() of the match's
|
|
## world, so a soak test can compare it with its clients' copies. 0 turns it off.
|
|
var world_hash_every: int = 0
|
|
## Runs ticks back to back instead of at the real tick rate. For tests and smoke runs.
|
|
var unthrottled: bool = false
|
|
## Logs a progress line every this many ticks. 0 turns progress lines off.
|
|
var log_every: int = 0
|
|
var fault: String = ""
|
|
## The name shown in server lists.
|
|
var server_name: String = NetDiscovery.DEFAULT_SERVER_NAME
|
|
## List servers to register with: {"host", "port"}. Hosts may be names.
|
|
var lists: Array[Dictionary] = []
|
|
## Answer LAN discovery. On by default for a listening server.
|
|
var lan: bool = true
|
|
## TCP port for the health endpoint; 0 for none.
|
|
var health_port: int = 0
|
|
var health_bind: String = "127.0.0.1"
|
|
## A file whose appearance asks the server to stop; empty for none.
|
|
var stop_file: String = ""
|
|
## Human-readable problems found while parsing. Empty when the config is usable.
|
|
var errors: Array[String] = []
|
|
|
|
|
|
## Parses arguments. Arguments before `--server` are ignored unless `--server` is absent,
|
|
## in which case nothing is parsed and `server` stays false.
|
|
static func parse(args: PackedStringArray) -> ServerConfig:
|
|
var config: ServerConfig = ServerConfig.new()
|
|
var start: int = args.find("--server")
|
|
if start < 0:
|
|
return config
|
|
config.server = true
|
|
for index: int in range(start + 1, args.size()):
|
|
var arg: String = args[index]
|
|
if arg.begins_with("--config="):
|
|
for from_file: String in config._read_file(arg.substr("--config=".length())):
|
|
config._parse_one(from_file)
|
|
else:
|
|
config._parse_one(arg)
|
|
config._validate()
|
|
return config
|
|
|
|
|
|
func is_valid() -> bool:
|
|
return errors.is_empty()
|
|
|
|
|
|
## The values that matter for reproducing a run, for the start log line.
|
|
func to_dictionary() -> Dictionary:
|
|
return {
|
|
"seed": match_seed,
|
|
"listen": listen,
|
|
"port": port,
|
|
"players": players,
|
|
"bots": bots,
|
|
"team_size": team_size,
|
|
"bot_difficulty": "mixed" if bot_difficulty < 0 else String(Tuning.BOT_DIFFICULTIES[bot_difficulty]["name"]),
|
|
"ticks": ticks,
|
|
"matches": matches,
|
|
"unthrottled": unthrottled,
|
|
"name": server_name,
|
|
"lan": lan and listen,
|
|
"lists": lists.size(),
|
|
}
|
|
|
|
|
|
func _parse_one(arg: String) -> void:
|
|
if arg == "--unthrottled":
|
|
unthrottled = true
|
|
return
|
|
if arg == "--listen":
|
|
listen = true
|
|
return
|
|
if arg == "--no-lan":
|
|
lan = false
|
|
return
|
|
var parts: PackedStringArray = arg.split("=", true, 1)
|
|
if parts.size() != 2 or not arg.begins_with("--"):
|
|
errors.append("unknown argument '%s'" % arg)
|
|
return
|
|
var key: String = parts[0]
|
|
var value: String = parts[1]
|
|
match key:
|
|
"--seed":
|
|
if _check_int(key, value):
|
|
match_seed = value.to_int()
|
|
has_seed = true
|
|
"--port":
|
|
if _check_int(key, value):
|
|
port = value.to_int()
|
|
"--players":
|
|
if _check_int(key, value):
|
|
players = value.to_int()
|
|
"--bots":
|
|
if _check_int(key, value):
|
|
bots = value.to_int()
|
|
"--team-size":
|
|
if _check_int(key, value):
|
|
team_size = value.to_int()
|
|
"--ticks":
|
|
if _check_int(key, value):
|
|
ticks = value.to_int()
|
|
"--log-every":
|
|
if _check_int(key, value):
|
|
log_every = value.to_int()
|
|
"--matches":
|
|
if _check_int(key, value):
|
|
matches = value.to_int()
|
|
"--world-hash-every":
|
|
if _check_int(key, value):
|
|
world_hash_every = value.to_int()
|
|
"--bot-difficulty":
|
|
var found: bool = value == "mixed"
|
|
for index: int in Tuning.BOT_DIFFICULTIES.size():
|
|
if Tuning.BOT_DIFFICULTIES[index]["name"] == value:
|
|
bot_difficulty = index
|
|
found = true
|
|
if not found:
|
|
errors.append("--bot-difficulty must be mixed, easy, normal or hard, got '%s'" % value)
|
|
"--fault":
|
|
fault = value
|
|
"--health-port":
|
|
if _check_int(key, value):
|
|
health_port = value.to_int()
|
|
"--health-bind":
|
|
if not value.is_valid_ip_address():
|
|
errors.append("--health-bind needs an IP address, got '%s'" % value)
|
|
else:
|
|
health_bind = value
|
|
"--stop-file":
|
|
stop_file = value
|
|
"--name":
|
|
server_name = NetDiscovery.clean_server_name(value)
|
|
"--list":
|
|
var target: Dictionary = parse_host_port(value, NetDiscovery.DEFAULT_LIST_PORT)
|
|
if target.is_empty():
|
|
errors.append("--list needs HOST or HOST:PORT with a port from 1 to 65535, got '%s'" % value)
|
|
else:
|
|
lists.append(target)
|
|
_:
|
|
errors.append("unknown argument '%s'" % arg)
|
|
|
|
|
|
## {"host", "port"} from "HOST" or "HOST:PORT", or empty if it doesn't parse. An
|
|
## IPv6 address goes in brackets when it has a port: "[::1]:24660".
|
|
static func parse_host_port(text: String, default_port: int) -> Dictionary:
|
|
var host: String = text
|
|
var port: int = default_port
|
|
if text.begins_with("["):
|
|
var close: int = text.find("]")
|
|
if close < 0:
|
|
return {}
|
|
host = text.substr(1, close - 1)
|
|
var rest: String = text.substr(close + 1)
|
|
if not rest.is_empty():
|
|
if not rest.begins_with(":") or not rest.substr(1).is_valid_int():
|
|
return {}
|
|
port = rest.substr(1).to_int()
|
|
elif text.count(":") == 1:
|
|
var at: int = text.find(":")
|
|
host = text.substr(0, at)
|
|
if not text.substr(at + 1).is_valid_int():
|
|
return {}
|
|
port = text.substr(at + 1).to_int()
|
|
if host.is_empty() or port < 1 or port > 65535:
|
|
return {}
|
|
return {"host": host, "port": port}
|
|
|
|
|
|
## The options in a config file, as command-line arguments.
|
|
func _read_file(path: String) -> Array[String]:
|
|
var args: Array[String] = []
|
|
var file: FileAccess = FileAccess.open(path, FileAccess.READ)
|
|
if file == null:
|
|
errors.append("couldn't read the config file '%s': %s" % [path, error_string(FileAccess.get_open_error())])
|
|
return args
|
|
var number: int = 0
|
|
while not file.eof_reached():
|
|
number += 1
|
|
var line: String = file.get_line().strip_edges()
|
|
if line.is_empty() or line.begins_with("#"):
|
|
continue
|
|
if line.begins_with("config"):
|
|
errors.append("%s:%d: a config file can't include another" % [path, number])
|
|
continue
|
|
var at: int = line.find("=")
|
|
if at < 0:
|
|
args.append("--" + line)
|
|
else:
|
|
args.append("--%s=%s" % [line.substr(0, at).strip_edges(), line.substr(at + 1).strip_edges()])
|
|
return args
|
|
|
|
|
|
func _check_int(key: String, value: String) -> bool:
|
|
if value.is_valid_int():
|
|
return true
|
|
errors.append("%s needs a whole number, got '%s'" % [key, value])
|
|
return false
|
|
|
|
|
|
func _validate() -> void:
|
|
if port < 1 or port > 65535:
|
|
errors.append("--port must be between 1 and 65535, got %d" % port)
|
|
if players < 0 or bots < 0:
|
|
errors.append("--players and --bots can't be negative")
|
|
if players + bots > Tuning.SOLO_PLAYERS:
|
|
errors.append(
|
|
"--players plus --bots is %d, more than the match size of %d"
|
|
% [players + bots, Tuning.SOLO_PLAYERS]
|
|
)
|
|
if listen and players > 0:
|
|
errors.append("--players is for a server that isn't listening; with --listen, people join over the network")
|
|
if team_size < 1 or team_size > Tuning.DUO_TEAM_SIZE:
|
|
errors.append("--team-size must be 1 (solo) or %d (duos), got %d" % [Tuning.DUO_TEAM_SIZE, team_size])
|
|
if ticks < 0:
|
|
errors.append("--ticks can't be negative")
|
|
if log_every < 0:
|
|
errors.append("--log-every can't be negative")
|
|
if matches < 0 or world_hash_every < 0:
|
|
errors.append("--matches and --world-hash-every can't be negative")
|
|
if world_hash_every > 0 and not listen:
|
|
errors.append("--world-hash-every is for a server started with --listen")
|
|
if not listen and (not lists.is_empty() or not lan):
|
|
errors.append("--list and --no-lan are for a server started with --listen")
|
|
if health_port < 0 or health_port > 65535:
|
|
errors.append("--health-port must be between 1 and 65535, or 0 for none, got %d" % health_port)
|
|
if fault not in FAULTS:
|
|
errors.append("unknown --fault '%s'" % fault)
|