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>
This commit is contained in:
@@ -32,6 +32,7 @@ continuity.
|
||||
| `tools/capture.sh <scene-or-scenario> <out.png>` | Renders the real client offscreen in a throwaway `tidewall-capture-*` Docker container (Xvfb, Mesa software rendering) and saves a PNG. Fails on a blank frame or a renderer fallback. |
|
||||
| `tools/godot.sh --script res://tools/island_map.gd -- --seed=N --out=res://captures/island.png` | Draws a top-down map of a seed's island, with a contour at each tide level. |
|
||||
| `make bot-matches` | Plays 20 bot-only matches (about ten minutes, under `nice`) and checks every one has a winner, under a tenth of deaths are drownings, and easy bots win less than an even share and take the fewest eliminations. `BOT_MATCH_SEEDS=5 BOT_MATCH_FIRST=40` changes the seeds; under 20 matches the difficulty checks are skipped. |
|
||||
| `make duo-matches` | M7: plays 10 bot-only duos matches (12 teams of two, under `nice`, about 5 min) and checks each is won by one team, bots go down and revive each other, no hit between teammates did damage, and the worst p99 tick is within budget. `DUO_MATCH_SEEDS`, `DUO_MATCH_FIRST` change the seeds. |
|
||||
| `make bot-builds` | M6: plays 40 bot-only matches (about 12 minutes, under `nice`) in which every other bot gathers and builds, and compares them with the rest. Builders must build in over a third of the fights they begin with the materials for a wall, lose fewer of the fights they build in than of the rest, and place no worse on average; every match's p99 tick must be within budget. `BOT_BUILDS_SEEDS=5 BOT_BUILDS_FIRST=40` changes the seeds; under 20 matches only completion and timing are judged. Lines in `build/bot_builds/matches.jsonl`. See docs/BALANCE.md. |
|
||||
| `make balance` | H3: plays 200 bot-only matches in four processes under `nice` (about 15 min) and writes `build/balance/report.txt`: match length, players standing over time, causes of death, eliminations by weapon and by difficulty. Fails if the median match is outside 12 to 18 minutes or a weapon takes over 35% of eliminations (`BALANCE_*` in tuning). `BALANCE_MATCHES`, `BALANCE_FIRST`, `BALANCE_JOBS` scale it. See docs/BALANCE.md. |
|
||||
| `make match` | Plays one whole offline match, lobby to results: a scripted player and 23 bots on a local server (about 25 s). Saves the command log to `build/match/match.tclog`, replays it and checks the replay ends on the same state hash. `MATCH_SEED=N` changes the seed; the default, 29, is one where the scripted player also builds. |
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
# Tidewall build entry points. Everything runs headless with the repo-local engine.
|
||||
GODOT := tools/godot.sh
|
||||
|
||||
.PHONY: qa-captures effects-captures app-icon deb deb-check bench dist dist-check build-captures poi-captures art figure figure-captures sea-captures models item-captures audio audio-check check import parse test test-selfcheck smoke capture-test terrain-capture binaries verify-engine balance bot-matches bot-builds match match-captures client-check client-captures hud-captures style-captures menu-captures chart-captures discovery-check fuzz stability soak soak-selfcheck server-package-check
|
||||
.PHONY: qa-captures effects-captures app-icon deb deb-check bench dist dist-check build-captures poi-captures art figure figure-captures sea-captures models item-captures audio audio-check check import parse test test-selfcheck smoke capture-test terrain-capture binaries verify-engine balance bot-matches duo-matches bot-builds match match-captures client-check client-captures hud-captures style-captures menu-captures chart-captures discovery-check fuzz stability soak soak-selfcheck server-package-check
|
||||
|
||||
## A8: regenerates every sound in assets/audio/ from tools/audio/ (about 6 s).
|
||||
audio: import
|
||||
@@ -116,6 +116,12 @@ balance: import
|
||||
bot-matches: import
|
||||
@tools/bot_matches.sh
|
||||
|
||||
## M7: plays 10 bot-only duos matches (12 teams of two, under nice) and checks each is
|
||||
## won by one team, bots go down and revive each other, teammates never hurt each other
|
||||
## and the ticks keep within budget. DUO_MATCH_SEEDS and DUO_MATCH_FIRST change the seeds.
|
||||
duo-matches: import
|
||||
@tools/duo_matches.sh
|
||||
|
||||
## M6: plays 40 bot-only matches in which every other bot gathers and builds (about 12
|
||||
## minutes, under nice) and checks the builders build in over a third of the fights they
|
||||
## can afford to, lose fewer of the fights they build in than of the rest, and place no
|
||||
@@ -156,6 +162,7 @@ client-captures: import
|
||||
hud-captures: import
|
||||
@CAPTURE_SIZE=1280x720 tools/capture.sh client_hud captures/hud_720.png
|
||||
@CAPTURE_SIZE=1280x720 tools/capture.sh client_hud_build captures/hud_build_720.png
|
||||
@CAPTURE_SIZE=1280x720 tools/capture.sh client_hud_downed captures/hud_downed_720.png
|
||||
@CAPTURE_SIZE=3840x2160 tools/capture.sh client_hud captures/hud_2160.png
|
||||
|
||||
## A10: every menu screen (captures/menu_*.png, about 5 min). Needs Docker. Look at them.
|
||||
|
||||
@@ -27,7 +27,7 @@ All of this is checked headless or with **software rendering in a container**. N
|
||||
## Known limitations
|
||||
|
||||
- **Untested on real hardware.** No real GPU, Wayland session or hybrid-graphics machine has run it yet ([docs/PLAY.md](docs/PLAY.md#tested-configurations)).
|
||||
- **Solo only.** Duos and reviving ([#30](https://gitea.eom.dev/claude/tidewall/issues/30)) aren't in this release.
|
||||
- **The 1.0.0 packages are solo only.** Duos with downs and revives ([#30](https://gitea.eom.dev/claude/tidewall/issues/30)) are on `main` since 1.0.0 was tagged: `--team-size=2` on a server, `--duos` or the Practice menu's Crew offline. Bots play as teammates and revive, but don't otherwise stick together.
|
||||
- Bots carry powder kegs but don't throw them ([#83](https://gitea.eom.dev/claude/tidewall/issues/83)).
|
||||
- Most bots fall early in a match ([#74](https://gitea.eom.dev/claude/tidewall/issues/74)). Bots build on `main` since 1.0.0 was tagged ([#29](https://gitea.eom.dev/claude/tidewall/issues/29)), but only cover walls, ramps and a last-stand ring of breakwaters, not forts. The 1.0.0 packages have bots that don't build.
|
||||
- **No gamepad support or tutorial** ([#53](https://gitea.eom.dev/claude/tidewall/issues/53), [#52](https://gitea.eom.dev/claude/tidewall/issues/52)). No character customization ([#43](https://gitea.eom.dev/claude/tidewall/issues/43)) or editing of placed pieces ([#18](https://gitea.eom.dev/claude/tidewall/issues/18)).
|
||||
|
||||
+11
@@ -67,6 +67,17 @@ to heal instead of running when badly hurt, and build ramps up to someone on a c
|
||||
or a steep rise. At the last stand they ring their spot with breakwaters. They don't
|
||||
use powder kegs or the line thrower. Offline play is a local server filled with bots,
|
||||
the same game code as online play. A downed duo partner can be revived, within `REVIVE_SECONDS`.
|
||||
In duos (M7) bots never target their teammate, crawl toward it when downed, and go to a
|
||||
downed teammate within `BOT_REVIVE_METRES` to revive it when they aren't in a fight.
|
||||
|
||||
**Duos rules (M7).** Teams are set by `Match` and held on each player
|
||||
(`SimEntity.team`), so the simulation enforces them: `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 (`DOWNED_HEALTH`, bleeding one point
|
||||
every `DOWNED_BLEED_INTERVAL_TICKS`, crawling at `DOWNED_CRAWL_SPEED`); a standing
|
||||
teammate within `REVIVE_RANGE` holding interact for `REVIVE_SECONDS` brings them back
|
||||
with `REVIVE_HEALTH`. Downed players are eliminated when their health runs out again or
|
||||
when no teammate is left standing, credited to whoever downed them.
|
||||
|
||||
## The island
|
||||
|
||||
|
||||
@@ -38,6 +38,7 @@ Replace `1.0.0` with the version you downloaded.
|
||||
The game opens on its main menu.
|
||||
|
||||
- **Practice** plays offline against bots on an island of its own. No network needed.
|
||||
Crew picks solo or duos, with a bot as your crewmate.
|
||||
- **Join a server** lists the servers it finds on your local network. Pick one, or type
|
||||
an address (`host` or `host:port`; the default port is 24650) for any other server.
|
||||
- **Settings** has Controls, Mouse, Graphics, Display and Audio tabs.
|
||||
@@ -46,6 +47,7 @@ You can also start straight into a match from a terminal:
|
||||
|
||||
./tidewall --offline # practice against 23 bots
|
||||
./tidewall --offline --bots=5 --seed=42 # fewer bots, a chosen island
|
||||
./tidewall --offline --duos # duos, with the first bot as your crewmate
|
||||
./tidewall --connect=192.0.2.7:24650 --name=Mara
|
||||
./tidewall --headless --browse # print the LAN's servers, then quit
|
||||
./tidewall --headless --browse --list=lists.example.org:24660 # and a list server's
|
||||
@@ -54,6 +56,20 @@ On a server, matches run back to back: a short lobby, a countdown, the drop, the
|
||||
and the results, then a new island. If you join during a match you wait in the lobby
|
||||
for the next one. Leaving during a match counts as being eliminated where you stood.
|
||||
|
||||
### Duos
|
||||
|
||||
In duos you play in a crew of two, on a server started with `--team-size=2` or in
|
||||
practice. Crewmates can't hurt each other, with any weapon or keg.
|
||||
|
||||
- When your health runs out while your crewmate is still standing, you go **down**
|
||||
instead of out. You crawl, slowly, and can't fire, build, loot or use anything. Your
|
||||
health becomes 60 to bleed, one point every half second, and hits still take it.
|
||||
- Your crewmate hauls you up by standing beside you (within 2 m) and holding **Pick
|
||||
up** (E) for 6 seconds without a break. You get up with 30 health.
|
||||
- You're out when you bleed out, when you're finished off, or when your crewmate goes
|
||||
down or out too: a crew with nobody standing is eliminated, and both share its place.
|
||||
- Drowning still takes a downed player, and faster than bleeding.
|
||||
|
||||
## Controls
|
||||
|
||||
Every key can be rebound in Settings → Controls. Mouse sensitivity and inversion are on
|
||||
|
||||
@@ -49,6 +49,7 @@ server with exit code 2 instead of running the wrong match.
|
||||
| `port=N` | 24650 | UDP port for players. LAN discovery uses this port plus one. |
|
||||
| `bots=N` | 0 | Any number above 0 fills each match's empty places with bots. |
|
||||
| `bot-difficulty=` | `mixed` | `easy`, `normal`, `hard` or `mixed`. |
|
||||
| `team-size=N` | 1 | 1 for solo, 2 for duos: players pair up in the order they join (bots fill in after), can't hurt their teammate, and go down instead of out while their teammate stands. |
|
||||
| `name=NAME` | `Tidewall server` | The name shown in server lists. |
|
||||
| `list=HOST[:PORT]` | none | Register with a list server, so people off your LAN can find you. Can be given more than once. |
|
||||
| `no-lan` | off | Don't answer LAN discovery. |
|
||||
|
||||
@@ -26,6 +26,10 @@ UDP port (default 24650). LAN discovery answers on the port plus one.
|
||||
.BI \-\-bots= n
|
||||
Fill each match's empty places with bots.
|
||||
.TP
|
||||
.BI \-\-team\-size= n
|
||||
1 for solo (the default), 2 for duos: pairs who can't hurt each other and go
|
||||
down instead of out while their teammate stands.
|
||||
.TP
|
||||
.BI \-\-name= name
|
||||
The name shown in server lists.
|
||||
.TP
|
||||
|
||||
@@ -30,6 +30,9 @@ The name to play under.
|
||||
.TP
|
||||
.B \-\-offline
|
||||
Start a practice match against bots at once.
|
||||
.TP
|
||||
.B \-\-duos
|
||||
With \-\-offline, play duos with the first bot as your crewmate.
|
||||
.SH FILES
|
||||
.TP
|
||||
.I ~/.local/share/godot/app_userdata/Tidewall/
|
||||
|
||||
@@ -62,11 +62,11 @@ func _ready() -> void:
|
||||
menus.show_screen("main", false)
|
||||
|
||||
|
||||
## Starts an offline match against bots.
|
||||
func start_practice(bots: int, difficulty: int) -> void:
|
||||
## Starts an offline match against bots, solo or in duos (`team_size` 2, M7).
|
||||
func start_practice(bots: int, difficulty: int, team_size: int = 1) -> void:
|
||||
var match_seed: int = int(Time.get_unix_time_from_system() * 1000.0) & 0x7FFFFFFF
|
||||
var practice: ClientSession = ClientSession.new()
|
||||
practice.play_offline(match_seed, bots, null, difficulty)
|
||||
practice.play_offline(match_seed, bots, LocalServer.offline_rules(bots, team_size), difficulty)
|
||||
_begin(practice)
|
||||
|
||||
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
## tidewall the main menu (with a window)
|
||||
## tidewall --offline an offline match against bots
|
||||
## tidewall --connect=HOST[:PORT] join a server
|
||||
## options: --name=NAME --seed=N --bots=N (offline) --autoplay
|
||||
## options: --name=NAME --seed=N --bots=N (offline) --duos (offline) --autoplay
|
||||
## --client-seconds=N quit after N seconds, saying what happened
|
||||
## tidewall --browse [--list=HOST[:PORT]]... [--lan-target=ADDRESS]... [--lan-port=N]
|
||||
## print the servers found on the LAN and in list
|
||||
@@ -25,6 +25,8 @@ var player_name: String = DEFAULT_NAME
|
||||
var match_seed: int = 0
|
||||
var has_seed: bool = false
|
||||
var bots: int = DEFAULT_BOTS
|
||||
## Offline in duos (M7) with --duos: the player and the first bot are a team.
|
||||
var team_size: int = 1
|
||||
var autoplay: bool = false
|
||||
## Quit after this many seconds; 0 runs until the window is closed.
|
||||
var seconds: float = 0.0
|
||||
@@ -43,7 +45,7 @@ var errors: Array[String] = []
|
||||
|
||||
## Every option parse() knows, by name.
|
||||
const OPTIONS: Array[String] = [
|
||||
"--offline", "--autoplay", "--browse", "--list", "--lan-port", "--lan-target",
|
||||
"--offline", "--autoplay", "--duos", "--browse", "--list", "--lan-port", "--lan-target",
|
||||
"--connect", "--name", "--seed", "--bots", "--client-seconds",
|
||||
]
|
||||
|
||||
@@ -73,6 +75,8 @@ static func parse(args: PackedStringArray) -> ClientConfig:
|
||||
config.asked = true
|
||||
"--autoplay":
|
||||
config.autoplay = true
|
||||
"--duos":
|
||||
config.team_size = Tuning.DUO_TEAM_SIZE
|
||||
"--browse":
|
||||
config.asked = true
|
||||
config.browse = true
|
||||
@@ -120,6 +124,8 @@ static func parse(args: PackedStringArray) -> ClientConfig:
|
||||
_:
|
||||
if arg.begins_with("--"):
|
||||
config.errors.append("unknown option '%s'" % arg)
|
||||
if config.team_size > 1 and not config.host.is_empty():
|
||||
config.errors.append("--duos is for an offline match; a server decides its own teams")
|
||||
if config.browse and not config.host.is_empty():
|
||||
config.errors.append("--browse and --connect can't be used together")
|
||||
return config
|
||||
|
||||
+1
-1
@@ -55,7 +55,7 @@ func _ready() -> void:
|
||||
_session.input.autoplay = _config.autoplay
|
||||
if _config.host.is_empty():
|
||||
var match_seed: int = _config.match_seed if _config.has_seed else int(Time.get_unix_time_from_system() * 1000.0) & 0x7FFFFFFF
|
||||
_session.play_offline(match_seed, _config.bots)
|
||||
_session.play_offline(match_seed, _config.bots, LocalServer.offline_rules(_config.bots, _config.team_size))
|
||||
else:
|
||||
var error: Error = _session.connect_to(_config.host, _config.port, _config.player_name)
|
||||
if error != OK:
|
||||
|
||||
+110
-3
@@ -178,6 +178,8 @@ func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
return PlayerCommand.from_input(sim.tick, Vector2.ZERO, 0.0, 0.0)
|
||||
if me.drop_state != Drop.NONE:
|
||||
return _drop(sim, grid, world)
|
||||
if me.downed:
|
||||
return _crawl(sim, world, me)
|
||||
_count_building(world, me)
|
||||
_sense(sim, world, me)
|
||||
_check_tide(sim, world, me)
|
||||
@@ -205,6 +207,8 @@ func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
and not _fleeing and not retreating and not covering and distance <= Tuning.BOT_BRAWL_METRES and provoked)
|
||||
var interact: bool = false
|
||||
var walk: bool = true
|
||||
var patient: SimEntity = _patient(sim, world, me) if not me.swimming else null
|
||||
var tending: bool = false
|
||||
|
||||
# Where to go.
|
||||
_direct_on = false
|
||||
@@ -234,6 +238,14 @@ func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
elif brawling:
|
||||
state = "brawl"
|
||||
_stop()
|
||||
elif patient != null:
|
||||
# A teammate is down (M7): get to them and hold interact until they're up.
|
||||
state = "revive"
|
||||
if me.position.distance_to(patient.position) <= Tuning.REVIVE_RANGE * 0.75:
|
||||
_stop()
|
||||
tending = true
|
||||
else:
|
||||
_go(patient.position, Tuning.REVIVE_RANGE * 0.5)
|
||||
elif target != null and armed:
|
||||
state = "chase"
|
||||
_go(_last_seen, 3.0)
|
||||
@@ -361,6 +373,14 @@ func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
chosen_material = _piece_material
|
||||
if _piece_kind != StructureSet.RAMP:
|
||||
direction = Vector2.ZERO
|
||||
if tending:
|
||||
var to_patient: Vector2 = Vector2(patient.position.x - me.position.x, patient.position.z - me.position.z)
|
||||
if to_patient.length() > 0.05:
|
||||
yaw = atan2(to_patient.x, to_patient.y)
|
||||
pitch = 0.0
|
||||
direction = Vector2.ZERO
|
||||
buttons = PlayerCommand.BUTTON_INTERACT
|
||||
chosen_material = 0
|
||||
_track_fight(sim, world, me, buttons)
|
||||
var forward: Vector2 = Vector2(sin(yaw), cos(yaw))
|
||||
var right: Vector2 = Vector2(-cos(yaw), sin(yaw))
|
||||
@@ -368,6 +388,64 @@ func think(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
return PlayerCommand.from_input(sim.tick, move, yaw, pitch, buttons, selection, chosen_material)
|
||||
|
||||
|
||||
# Duos (M7)
|
||||
|
||||
## The nearest standing teammate, or null.
|
||||
func _standing_teammate(sim: Simulation, world: BotWorld, me: SimEntity) -> SimEntity:
|
||||
if me == null or me.team < 0:
|
||||
return null
|
||||
var best: SimEntity = null
|
||||
var best_gap: float = INF
|
||||
for other_id: int in world.player_ids:
|
||||
var other: SimEntity = sim.entities.find(other_id)
|
||||
if not Simulation.is_standing(other) or not sim.are_teammates(me, other) or other.drop_state != Drop.NONE:
|
||||
continue
|
||||
var gap: float = me.position.distance_squared_to(other.position)
|
||||
if gap < best_gap:
|
||||
best = other
|
||||
best_gap = gap
|
||||
return best
|
||||
|
||||
|
||||
## The nearest downed teammate within Tuning.BOT_REVIVE_METRES, or null.
|
||||
func _patient(sim: Simulation, world: BotWorld, me: SimEntity) -> SimEntity:
|
||||
var best: SimEntity = null
|
||||
var best_gap: float = Tuning.BOT_REVIVE_METRES * Tuning.BOT_REVIVE_METRES
|
||||
for other_id: int in world.player_ids:
|
||||
var other: SimEntity = sim.entities.find(other_id)
|
||||
if other == null or not other.downed or other.eliminated or not sim.are_teammates(me, other):
|
||||
continue
|
||||
var gap: float = me.position.distance_squared_to(other.position)
|
||||
if gap <= best_gap:
|
||||
best = other
|
||||
best_gap = gap
|
||||
return best
|
||||
|
||||
|
||||
## Downed: crawl straight for the nearest standing teammate, and stop beside them.
|
||||
func _crawl(sim: Simulation, world: BotWorld, me: SimEntity) -> PlayerCommand:
|
||||
state = "downed"
|
||||
_stop()
|
||||
_forget_target()
|
||||
var yaw: float = float(me.yaw) / PlayerCommand.YAW_STEPS * TAU
|
||||
var move: Vector2 = Vector2.ZERO
|
||||
var nearest: SimEntity = null
|
||||
var nearest_gap: float = INF
|
||||
for other_id: int in world.player_ids:
|
||||
var other: SimEntity = sim.entities.find(other_id)
|
||||
if not Simulation.is_standing(other) or not sim.are_teammates(me, other):
|
||||
continue
|
||||
var gap: float = me.position.distance_squared_to(other.position)
|
||||
if gap < nearest_gap:
|
||||
nearest = other
|
||||
nearest_gap = gap
|
||||
if nearest != null and nearest_gap > Tuning.REVIVE_RANGE * Tuning.REVIVE_RANGE * 0.25:
|
||||
var to: Vector2 = Vector2(nearest.position.x - me.position.x, nearest.position.z - me.position.z)
|
||||
yaw = atan2(to.x, to.y)
|
||||
move = Vector2(0.0, 1.0)
|
||||
return PlayerCommand.from_input(sim.tick, move, yaw, 0.0)
|
||||
|
||||
|
||||
# Movement goals
|
||||
|
||||
func _go(goal: Vector3, radius: float) -> void:
|
||||
@@ -388,6 +466,13 @@ func _stop() -> void:
|
||||
## Rides the barge to within reach of a loot marker near its route, then glides to it.
|
||||
func _drop(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
state = "drop"
|
||||
var rider: SimEntity = sim.entities.find(player_id)
|
||||
if _landing < 0 and rider != null and rider.team >= 0 and world.team_landings.has(rider.team):
|
||||
# Duos (M7): land with the teammate who already chose.
|
||||
_landing = int(world.team_landings[rider.team])
|
||||
_marker = _landing
|
||||
_marker_since = sim.tick
|
||||
_go(world.markers[_landing], 2.0)
|
||||
if _landing < 0 and not world.markers.is_empty() and sim.drop != null:
|
||||
var rng: RandomNumberGenerator = nav.stream(sim)
|
||||
var a: Vector2 = Vector2(sim.drop.start.x, sim.drop.start.z)
|
||||
@@ -413,6 +498,8 @@ func _drop(sim: Simulation, grid: NavGrid, world: BotWorld) -> PlayerCommand:
|
||||
best_crowd = crowd
|
||||
_landing = pick
|
||||
world.landings.append(world.markers[_landing])
|
||||
if rider != null and rider.team >= 0:
|
||||
world.team_landings[rider.team] = _landing
|
||||
_marker = _landing
|
||||
_marker_since = sim.tick
|
||||
_go(world.markers[_landing], 2.0)
|
||||
@@ -455,6 +542,18 @@ func _sense(sim: Simulation, world: BotWorld, me: SimEntity) -> void:
|
||||
elif tick - _last_seen_tick > roundi(Tuning.BOT_MEMORY_SECONDS * TICKS):
|
||||
_forget_target()
|
||||
target = null
|
||||
if target != null and target.downed and target_visible:
|
||||
# Duos (M7): a downed target can't shoot back, but its teammate can. Turn on the
|
||||
# teammate if they're in view; otherwise finish the job.
|
||||
for other_id: int in world.player_ids:
|
||||
var other: SimEntity = sim.entities.find(other_id)
|
||||
if Simulation.is_standing(other) and other.drop_state == Drop.NONE and sim.are_teammates(target, other) \
|
||||
and me.position.distance_to(other.position) <= minf(_sight, Tuning.BOT_ENGAGE_METRES) and _can_see(sim, world, me, other, false):
|
||||
target_id = other.id
|
||||
_acquired_tick = tick
|
||||
_last_seen = other.position
|
||||
_last_seen_tick = tick
|
||||
return
|
||||
if target != null and target_visible:
|
||||
return
|
||||
# Look for someone new, nearest first, with a few sight lines at most.
|
||||
@@ -463,7 +562,7 @@ func _sense(sim: Simulation, world: BotWorld, me: SimEntity) -> void:
|
||||
if other_id == player_id or other_id == target_id:
|
||||
continue
|
||||
var other: SimEntity = sim.entities.find(other_id)
|
||||
if other == null or other.eliminated or other.drop_state != Drop.NONE:
|
||||
if other == null or other.eliminated or other.drop_state != Drop.NONE or sim.are_teammates(me, other):
|
||||
continue
|
||||
# A bot picks out a new opponent only this close; one who shoots it first is
|
||||
# fought at any range it can see (H3).
|
||||
@@ -974,10 +1073,18 @@ func _hunt(sim: Simulation, world: BotWorld) -> void:
|
||||
if arrived and not _holding:
|
||||
_holding = true
|
||||
_hunt_until = sim.tick + roundi(Tuning.BOT_HOLD_SECONDS * TICKS)
|
||||
var me: SimEntity = sim.entities.find(player_id)
|
||||
var mate: SimEntity = _standing_teammate(sim, world, me)
|
||||
var strayed: bool = mate != null and me.position.distance_to(mate.position) > Tuning.BOT_REGROUP_METRES
|
||||
if strayed and (_holding or _hunt_goal.distance_to(mate.position) > Tuning.BOT_REGROUP_METRES * 0.5):
|
||||
# Duos (M7): too far from the teammate to help them up; go back to them.
|
||||
_holding = false
|
||||
_hunt_until = sim.tick
|
||||
if (not _goal_set and not _holding) or sim.tick >= _hunt_until:
|
||||
var phase: int = sim.tide.phase_at(sim.tick) if sim.tide != null else 0
|
||||
var me: SimEntity = sim.entities.find(player_id)
|
||||
_hunt_goal = world.random_safe_near(nav.stream(sim), phase, me.position, Tuning.BOT_ROAM_METRES)
|
||||
var around: Vector3 = mate.position if strayed else me.position
|
||||
var radius: float = Tuning.BOT_REGROUP_METRES * 0.3 if strayed else Tuning.BOT_ROAM_METRES
|
||||
_hunt_goal = world.random_safe_near(nav.stream(sim), phase, around, radius)
|
||||
_hunt_until = sim.tick + 40 * TICKS
|
||||
_holding = false
|
||||
_go(_hunt_goal, 4.0)
|
||||
|
||||
@@ -44,6 +44,9 @@ var phase_tops: Array[Vector3] = []
|
||||
var walkable: PackedByteArray = PackedByteArray()
|
||||
## Where bots have chosen to land this match, so later bots can spread out (H3).
|
||||
var landings: Array[Vector3] = []
|
||||
## Duos (M7): team -> the marker index its first bot chose to land at, so its
|
||||
## teammate lands there too.
|
||||
var team_landings: Dictionary = {}
|
||||
## Victim entity ID -> attacker entity ID, for hits landed during the last tick.
|
||||
var attackers: Dictionary = {}
|
||||
## Builder entity ID -> the kinds of the pieces it placed during the last tick (M6).
|
||||
|
||||
@@ -176,9 +176,9 @@ func hear(records: Array[Dictionary]) -> void:
|
||||
|
||||
|
||||
## Puts the held item's model in the figure's hand; the figure points it where the
|
||||
## player looks. Nothing is held aboard the barge, falling, gliding or swimming.
|
||||
## player looks. Nothing is held aboard the barge, falling, gliding, swimming or down.
|
||||
func _hold(figure: FigureRig, entity: SimEntity) -> void:
|
||||
var busy: bool = entity.drop_state != Drop.NONE or entity.swimming or entity.eliminated
|
||||
var busy: bool = entity.drop_state != Drop.NONE or entity.swimming or entity.eliminated or entity.downed
|
||||
figure.hand().visible = not busy
|
||||
if busy:
|
||||
return
|
||||
|
||||
@@ -231,6 +231,22 @@ static func _clips() -> Dictionary:
|
||||
[0.0, swim], [0.325, swim_pull], [0.65, mirror(swim)], [0.975, mirror(swim_pull)],
|
||||
]]
|
||||
|
||||
# Downed in duos (M7): on hands and knees, head up, crawling a hand and knee at a time.
|
||||
var downed: Dictionary = {
|
||||
"hips": Vector3(78, 0, 0), "waist": Vector3(-4, 0, 0), "neck": Vector3(-52, 0, 0),
|
||||
"shoulder_r": Vector3(-84, 0, -6), "elbow_r": Vector3(-8, 0, 0),
|
||||
"shoulder_l": Vector3(-84, 0, 6), "elbow_l": Vector3(-8, 0, 0),
|
||||
"hip_r": Vector3(-78, 0, -4), "knee_r": Vector3(92, 0, 0),
|
||||
"hip_l": Vector3(-78, 0, 4), "knee_l": Vector3(92, 0, 0), "lift": Vector3(0, -0.5, 0),
|
||||
}
|
||||
var downed_reach: Dictionary = over(downed, {
|
||||
"shoulder_r": Vector3(-104, 0, -6), "hip_l": Vector3(-64, 0, 4), "knee_l": Vector3(84, 0, 0),
|
||||
"waist": Vector3(-4, 6, 0),
|
||||
})
|
||||
clips["downed"] = [1.6, true, [
|
||||
[0.0, downed], [0.4, downed_reach], [0.8, downed], [1.2, mirror(downed_reach)],
|
||||
]]
|
||||
|
||||
# How the held item is carried (arms only).
|
||||
# Long things at the chest, the right hand at the grip and the left reaching
|
||||
# along to the fore-end.
|
||||
|
||||
@@ -55,7 +55,7 @@ const COLOURS: Dictionary = {
|
||||
}
|
||||
const COAT_SHADE: float = 0.28
|
||||
## The states of `move`, in input order.
|
||||
const STATES: Array[String] = ["ground", "crouch", "air", "skydive", "glide", "swim", "aboard"]
|
||||
const STATES: Array[String] = ["ground", "crouch", "air", "skydive", "glide", "swim", "aboard", "downed"]
|
||||
const HOLDS: Array[String] = ["long", "short", "carry"]
|
||||
const ACTIONS: Array[String] = ["fire_long", "fire_short", "swing", "throw", "build"]
|
||||
## How long a figure must be off the ground before it's drawn in the air, so steps
|
||||
@@ -304,6 +304,9 @@ static func state_of(entity: SimEntity, airborne: bool) -> String:
|
||||
return "glide"
|
||||
if entity.swimming:
|
||||
return "swim"
|
||||
if entity.downed:
|
||||
# Duos (M7): down on hands and knees, crawling.
|
||||
return "downed"
|
||||
if airborne:
|
||||
return "air"
|
||||
return "crouch" if entity.crouching else "ground"
|
||||
|
||||
@@ -71,6 +71,10 @@ var practice_bots: int = Tuning.SOLO_PLAYERS - 1:
|
||||
var practice_difficulty: int = -1:
|
||||
set(value):
|
||||
practice_difficulty = clampi(value, -1, Tuning.BOT_DIFFICULTIES.size() - 1)
|
||||
## Practice solo (1) or in duos with a bot teammate (Tuning.DUO_TEAM_SIZE), M7.
|
||||
var practice_team_size: int = 1:
|
||||
set(value):
|
||||
practice_team_size = clampi(value, 1, Tuning.DUO_TEAM_SIZE)
|
||||
|
||||
|
||||
func shadow_distance() -> float:
|
||||
@@ -118,6 +122,7 @@ func save(path: String = DEFAULT_PATH) -> Error:
|
||||
config.set_value("player", "last_server", last_server)
|
||||
config.set_value("practice", "bots", practice_bots)
|
||||
config.set_value("practice", "difficulty", practice_difficulty)
|
||||
config.set_value("practice", "team_size", practice_team_size)
|
||||
return config.save(path)
|
||||
|
||||
|
||||
@@ -144,6 +149,7 @@ static func load_from(path: String = DEFAULT_PATH) -> GameSettings:
|
||||
settings.last_server = String(server_value).strip_edges().left(255)
|
||||
settings.practice_bots = _int(config, "practice", "bots", settings.practice_bots)
|
||||
settings.practice_difficulty = _int(config, "practice", "difficulty", settings.practice_difficulty)
|
||||
settings.practice_team_size = _int(config, "practice", "team_size", settings.practice_team_size)
|
||||
return settings
|
||||
|
||||
|
||||
|
||||
@@ -14,6 +14,8 @@ const FONT_SMALL: int = 13
|
||||
const FONT_BODY: int = 16
|
||||
const FONT_TITLE: int = 22
|
||||
const MARGIN: float = 18.0
|
||||
## Shown while downed in duos (M7).
|
||||
const DOWN_TEXT: String = "DOWN · bleeding out · crawl to your crewmate, who can haul you up with interact"
|
||||
|
||||
var state: HudState = HudState.new()
|
||||
|
||||
@@ -24,6 +26,8 @@ var _vitals: Vitals
|
||||
var _hotbar: HBoxContainer
|
||||
var _materials: VBoxContainer
|
||||
var _build: Label
|
||||
## Down in duos (M7): what to do about it, above the hotbar.
|
||||
var _down: Label
|
||||
var _reticle: Reticle
|
||||
var _hurt: HurtEdge
|
||||
## When a feed line was first shown (msec), so lines fade after HudState.FEED_SECONDS.
|
||||
@@ -90,6 +94,14 @@ func _init() -> void:
|
||||
_build.size = Vector2(520.0, 24.0)
|
||||
_build.position = Vector2(-260.0, -112.0 - MARGIN - 30.0)
|
||||
add_child(_build)
|
||||
_down = _label(FONT_BODY, Palette.WARNING)
|
||||
_down.set_anchors_preset(Control.PRESET_CENTER_BOTTOM)
|
||||
_down.horizontal_alignment = HORIZONTAL_ALIGNMENT_CENTER
|
||||
_down.size = Vector2(720.0, 24.0)
|
||||
_down.position = Vector2(-360.0, -112.0 - MARGIN - 30.0)
|
||||
_down.text = DOWN_TEXT
|
||||
_down.visible = false
|
||||
add_child(_down)
|
||||
|
||||
_materials = VBoxContainer.new()
|
||||
_materials.set_anchors_preset(Control.PRESET_BOTTOM_RIGHT)
|
||||
@@ -157,6 +169,7 @@ func show_state(shown: HudState) -> void:
|
||||
var count: int = shown.materials[code] if code < shown.materials.size() else 0
|
||||
(_materials.get_child(code) as Label).text = "%s %d" % [Materials.NAMES[code].replace("_", " ").capitalize(), count]
|
||||
|
||||
_down.visible = shown.playing and shown.downed
|
||||
_build.visible = shown.playing and not shown.build.is_empty()
|
||||
if _build.visible:
|
||||
var build: Dictionary = shown.build
|
||||
|
||||
@@ -25,6 +25,8 @@ var standing: int = 0
|
||||
var total: int = 0
|
||||
## Lines for the kill feed, oldest first: {"text", "you"}.
|
||||
var feed: Array[Dictionary] = []
|
||||
## Down in duos (M7): crawling, bleeding, waiting for a crewmate to haul them up.
|
||||
var downed: bool = false
|
||||
## True when the aiming reticle is shown: playing, on foot or swimming.
|
||||
var reticle: bool = false
|
||||
## Hit feedback (A7, HitFeedback): the marker for a shot that struck someone and the
|
||||
@@ -50,9 +52,11 @@ static func from_client(game: ClientGame, input: ClientInput, own_handle: int, f
|
||||
state.playing = true
|
||||
state.health = drawn.health if drawn != null else me.health
|
||||
state.armor = drawn.armor if drawn != null else me.armor
|
||||
state.reticle = me.drop_state == Drop.NONE
|
||||
state.reticle = me.drop_state == Drop.NONE and not me.downed
|
||||
state.downed = me.downed
|
||||
_fill_carried(state, me)
|
||||
state.build = build_of(input.build_mode, input.build_kind, input.material, me.materials)
|
||||
if not me.downed:
|
||||
state.build = build_of(input.build_mode, input.build_kind, input.material, me.materials)
|
||||
return state
|
||||
|
||||
|
||||
@@ -78,9 +82,11 @@ static func from_match(flow: Match, handle: int, build_mode: bool = false, build
|
||||
state.playing = true
|
||||
state.health = me.health
|
||||
state.armor = me.armor
|
||||
state.reticle = me.drop_state == Drop.NONE
|
||||
state.reticle = me.drop_state == Drop.NONE and not me.downed
|
||||
state.downed = me.downed
|
||||
_fill_carried(state, me)
|
||||
state.build = build_of(build_mode, build_kind, material, me.materials)
|
||||
if not me.downed:
|
||||
state.build = build_of(build_mode, build_kind, material, me.materials)
|
||||
return state
|
||||
|
||||
|
||||
@@ -112,7 +118,10 @@ static func feed_lines(entries: Array[Dictionary], own_handle: int) -> Array[Dic
|
||||
var by_is_you: bool = int(entry.get("by", 0)) == own_handle and own_handle != 0
|
||||
var victim: String = "You" if victim_is_you else String(entry.get("victim_name", "Someone"))
|
||||
var by: String = "You" if by_is_you else String(entry.get("by_name", ""))
|
||||
lines.append({"text": feed_text(victim, by, String(entry.get("cause", "none")), int(entry.get("item", -1)), victim_is_you), "you": victim_is_you or by_is_you})
|
||||
var text: String = feed_text(victim, by, String(entry.get("cause", "none")), int(entry.get("item", -1)), victim_is_you)
|
||||
if bool(entry.get("downed", false)):
|
||||
text = downed_text(victim, by, victim_is_you)
|
||||
lines.append({"text": text, "you": victim_is_you or by_is_you})
|
||||
return lines
|
||||
|
||||
|
||||
@@ -136,6 +145,13 @@ static func feed_text(victim: String, by: String, cause: String, item: int, vict
|
||||
return "%s is out" % victim
|
||||
|
||||
|
||||
## A down in duos (M7): the player isn't out until they bleed out or their team falls.
|
||||
static func downed_text(victim: String, by: String, victim_is_you: bool) -> String:
|
||||
if not by.is_empty() and by != victim:
|
||||
return "%s knocked %s down" % [by, "you" if victim_is_you else victim]
|
||||
return "%s %s down" % [victim, "are" if victim_is_you else "is"]
|
||||
|
||||
|
||||
## "flintlock_pistol" -> "Flintlock Pistol".
|
||||
static func item_name(id: String) -> String:
|
||||
return id.replace("_", " ").capitalize()
|
||||
|
||||
@@ -147,6 +147,7 @@ func _show_player(entity: SimEntity, record: PackedInt32Array, shown: Dictionary
|
||||
entity.crouching = flags & NetSnapshot.FLAG_CROUCHING != 0
|
||||
entity.swimming = flags & NetSnapshot.FLAG_SWIMMING != 0
|
||||
entity.eliminated = flags & NetSnapshot.FLAG_ELIMINATED != 0
|
||||
entity.downed = flags & NetSnapshot.FLAG_DOWNED != 0
|
||||
entity.drop_state = (flags >> NetSnapshot.FLAG_DROP_SHIFT) & 3
|
||||
# Only whether they last, for drawing: the ticks left aren't replicated.
|
||||
entity.reload_ticks = 1 if flags & NetSnapshot.FLAG_RELOADING != 0 else 0
|
||||
|
||||
@@ -15,7 +15,7 @@ class_name ClientPrediction
|
||||
extends RefCounted
|
||||
|
||||
## The flags movement reads and changes.
|
||||
const _MOVEMENT_FLAGS: int = NetSnapshot.FLAG_ON_GROUND | NetSnapshot.FLAG_SWIMMING | NetSnapshot.FLAG_ELIMINATED | (3 << NetSnapshot.FLAG_DROP_SHIFT)
|
||||
const _MOVEMENT_FLAGS: int = NetSnapshot.FLAG_ON_GROUND | NetSnapshot.FLAG_SWIMMING | NetSnapshot.FLAG_ELIMINATED | NetSnapshot.FLAG_DOWNED | (3 << NetSnapshot.FLAG_DROP_SHIFT)
|
||||
## Predicted ticks kept to compare with the server: four seconds.
|
||||
const HISTORY_TICKS: int = 120
|
||||
|
||||
|
||||
+7
-4
@@ -7,7 +7,8 @@
|
||||
## server -> FEED
|
||||
## u8 type, u8 standing, u8 players in the match, u8 entry count, then entries:
|
||||
## s32 victim handle, s32 eliminator handle (0 = none), u8 cause (CAUSES),
|
||||
## u8 item code plus one (0 = none), u8 place, u8 flags (1 = tied),
|
||||
## u8 item code plus one (0 = none), u8 place, u8 flags (1 = tied, 2 = downed,
|
||||
## not out: duos, M7),
|
||||
## str victim name, str eliminator name,
|
||||
## where str is u8 byte length then that many UTF-8 bytes (at most MAX_NAME_BYTES).
|
||||
##
|
||||
@@ -23,11 +24,12 @@ const ENTRY_FIXED_BYTES: int = 12
|
||||
const MAX_ENTRIES: int = 16
|
||||
const MAX_NAME_BYTES: int = 32
|
||||
const FLAG_TIED: int = 1
|
||||
const FLAG_DOWNED: int = 2
|
||||
|
||||
|
||||
## Encodes the count and `entries`, newest last. Each entry has "victim", "by",
|
||||
## "cause" (a name in CAUSES), "item" (-1 none), "place", "tied", "victim_name" and
|
||||
## "by_name". Only the newest MAX_ENTRIES are kept.
|
||||
## "cause" (a name in CAUSES), "item" (-1 none), "place", "tied", "downed", "victim_name"
|
||||
## and "by_name". Only the newest MAX_ENTRIES are kept.
|
||||
static func encode(standing: int, total: int, entries: Array[Dictionary]) -> PackedByteArray:
|
||||
var out: StreamPeerBuffer = StreamPeerBuffer.new()
|
||||
out.put_u8(MSG_FEED)
|
||||
@@ -42,7 +44,7 @@ static func encode(standing: int, total: int, entries: Array[Dictionary]) -> Pac
|
||||
out.put_u8(maxi(0, CAUSES.find(String(entry.get("cause", "none")))))
|
||||
out.put_u8(clampi(int(entry.get("item", -1)) + 1, 0, 255))
|
||||
out.put_u8(clampi(int(entry.get("place", 0)), 0, 255))
|
||||
out.put_u8(FLAG_TIED if bool(entry.get("tied", false)) else 0)
|
||||
out.put_u8((FLAG_TIED if bool(entry.get("tied", false)) else 0) | (FLAG_DOWNED if bool(entry.get("downed", false)) else 0))
|
||||
_put_name(out, String(entry.get("victim_name", "")))
|
||||
_put_name(out, String(entry.get("by_name", "")))
|
||||
return out.data_array
|
||||
@@ -67,6 +69,7 @@ static func decode(bytes: PackedByteArray) -> Dictionary:
|
||||
var entry: Dictionary = {
|
||||
"victim": bytes.decode_s32(at), "by": bytes.decode_s32(at + 4), "cause": CAUSES[cause],
|
||||
"item": int(bytes[at + 9]) - 1, "place": int(bytes[at + 10]), "tied": bytes[at + 11] & FLAG_TIED != 0,
|
||||
"downed": bytes[at + 11] & FLAG_DOWNED != 0,
|
||||
}
|
||||
at += ENTRY_FIXED_BYTES
|
||||
var names: Array[String] = []
|
||||
|
||||
@@ -16,7 +16,7 @@ class_name NetProtocol
|
||||
extends RefCounted
|
||||
|
||||
## Raised whenever the wire format changes in a way old clients can't read.
|
||||
const VERSION: int = 4
|
||||
const VERSION: int = 5
|
||||
const MAGIC: String = "TDWL"
|
||||
const CHANNEL_CONTROL: int = 0
|
||||
## Unreliable game traffic: commands up, snapshots down.
|
||||
|
||||
+10
-5
@@ -38,8 +38,8 @@ const MATCH_BYTES: int = 14
|
||||
## told. Exact, not quantized, so a prediction made from it matches the server's to the
|
||||
## bit: position and velocity (three f32 each, which is all a Vector3 holds), the water
|
||||
## level around the player (f64), which of the nine flood cells around the player that
|
||||
## water reaches (u16), swimming stamina in ticks (u16) and the player's FLAG_ bits (u8).
|
||||
const SELF_BYTES: int = 37
|
||||
## water reaches (u16), swimming stamina in ticks (u16) and the player's FLAG_ bits (u16).
|
||||
const SELF_BYTES: int = 38
|
||||
## Every bit of the nine-cell water mask.
|
||||
const WATER_EVERYWHERE: int = 0x1FF
|
||||
## The most commands one INPUT may carry. Clients send fewer; see Tuning.
|
||||
@@ -80,6 +80,8 @@ const FLAG_ELIMINATED: int = 1 << 3
|
||||
const FLAG_DROP_SHIFT: int = 4
|
||||
const FLAG_RELOADING: int = 1 << 6
|
||||
const FLAG_USING: int = 1 << 7
|
||||
## Down, not out (duos, M7): crawling and waiting for a teammate.
|
||||
const FLAG_DOWNED: int = 1 << 8
|
||||
|
||||
const _U8: int = 0
|
||||
const _S8: int = 1
|
||||
@@ -89,7 +91,7 @@ const _WIDTH: Array[int] = [1, 1, 2, 4]
|
||||
|
||||
## Per archetype: the wire type of every record index.
|
||||
const _TYPES: Dictionary = {
|
||||
SimEntity.ARCHETYPE_PLAYER: [_U8, _U16, _U16, _U16, _U16, _S8, _U8, _U8, _U8, _U8],
|
||||
SimEntity.ARCHETYPE_PLAYER: [_U8, _U16, _U16, _U16, _U16, _S8, _U8, _U8, _U16, _U8],
|
||||
SimEntity.ARCHETYPE_PICKUP: [_U8, _U16, _U16, _U16, _U8, _U16, _U8],
|
||||
SimEntity.ARCHETYPE_PROJECTILE: [_U8, _U16, _U16, _U16, _U8, _U32],
|
||||
}
|
||||
@@ -157,6 +159,8 @@ static func flags_of(entity: SimEntity) -> int:
|
||||
flags |= FLAG_RELOADING
|
||||
if entity.use_ticks > 0:
|
||||
flags |= FLAG_USING
|
||||
if entity.downed:
|
||||
flags |= FLAG_DOWNED
|
||||
return flags
|
||||
|
||||
|
||||
@@ -180,6 +184,7 @@ static func apply_self(player: SimEntity, own: Dictionary) -> void:
|
||||
player.crouching = flags & FLAG_CROUCHING != 0
|
||||
player.swimming = flags & FLAG_SWIMMING != 0
|
||||
player.eliminated = flags & FLAG_ELIMINATED != 0
|
||||
player.downed = flags & FLAG_DOWNED != 0
|
||||
player.drop_state = (flags >> FLAG_DROP_SHIFT) & 3
|
||||
|
||||
|
||||
@@ -257,7 +262,7 @@ static func encode_snapshot(header: Dictionary, removed: PackedInt32Array, recor
|
||||
out.put_double(own["water"])
|
||||
out.put_u16(int(own["water_mask"]) & WATER_EVERYWHERE)
|
||||
out.put_u16(clampi(int(own["stamina"]), 0, 65535))
|
||||
out.put_u8(int(own["flags"]) & 0xFF)
|
||||
out.put_u16(int(own["flags"]) & 0xFFFF)
|
||||
out.put_u8(removed.size())
|
||||
for entity_id: int in removed:
|
||||
_put_varint(out, entity_id)
|
||||
@@ -325,7 +330,7 @@ static func decode_snapshot(bytes: PackedByteArray) -> Dictionary:
|
||||
"water": bytes.decode_double(at + 24),
|
||||
"water_mask": bytes.decode_u16(at + 32) & WATER_EVERYWHERE,
|
||||
"stamina": bytes.decode_u16(at + 34),
|
||||
"flags": bytes[at + 36],
|
||||
"flags": bytes.decode_u16(at + 36),
|
||||
}
|
||||
for value: float in [own["position"].x, own["position"].y, own["position"].z, own["velocity"].x, own["velocity"].y, own["velocity"].z, own["water"]]:
|
||||
if not is_finite(value):
|
||||
|
||||
@@ -55,10 +55,11 @@ func _ready() -> void:
|
||||
if not config.has_seed:
|
||||
config.match_seed = _fresh_seed()
|
||||
Engine.max_fps = 0 if config.unthrottled else REALTIME_MAX_FPS
|
||||
var rules: MatchRules = null
|
||||
var rules: MatchRules = ServerLoop.immediate_rules(config.players, config.bots)
|
||||
if config.listen:
|
||||
rules = MatchRules.new()
|
||||
rules.fill_with_bots = config.bots > 0
|
||||
rules.team_size = config.team_size
|
||||
loop = ServerLoop.new(config.match_seed, config.players, config.bots, rules, config.bot_difficulty)
|
||||
if config.listen:
|
||||
var net: NetServer = NetServer.new()
|
||||
|
||||
@@ -17,6 +17,16 @@ var _accumulator: float = 0.0
|
||||
var _greeted: bool = false
|
||||
|
||||
|
||||
## Rules for an offline match of one person and `bots` bots on teams of `team_size`:
|
||||
## null for solo, which ServerLoop starts at once with its own rules.
|
||||
static func offline_rules(bots: int, team_size: int) -> MatchRules:
|
||||
if team_size <= 1:
|
||||
return null
|
||||
var rules: MatchRules = ServerLoop.immediate_rules(1, bots)
|
||||
rules.team_size = team_size
|
||||
return rules
|
||||
|
||||
|
||||
## A match of one person and `bots` bots. With `rules` null it starts at once, and a
|
||||
## new one starts after each one's results. `difficulty` is every bot's, as an index
|
||||
## into Tuning.BOT_DIFFICULTIES, or -1 to mix them.
|
||||
|
||||
@@ -119,7 +119,7 @@ func after_tick() -> void:
|
||||
feed_changes = PackedByteArray()
|
||||
own_changes.clear()
|
||||
for event: Dictionary in flow.events:
|
||||
if event["type"] == "placed" or event["type"] == "match_started":
|
||||
if event["type"] in ["placed", "match_started", "downed", "revived"]:
|
||||
feed_changed = true
|
||||
if event["type"] == "phase":
|
||||
changed = true
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
## 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] [--ticks=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]
|
||||
@@ -24,6 +24,9 @@
|
||||
## 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
|
||||
@@ -46,6 +49,8 @@ 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.
|
||||
@@ -107,6 +112,7 @@ func to_dictionary() -> Dictionary:
|
||||
"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,
|
||||
@@ -147,6 +153,9 @@ func _parse_one(arg: String) -> void:
|
||||
"--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()
|
||||
@@ -260,6 +269,8 @@ func _validate() -> void:
|
||||
)
|
||||
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:
|
||||
|
||||
@@ -16,8 +16,8 @@
|
||||
## - Falloff: full damage at the middle, down linearly to Tuning.BLAST_EDGE_FACTOR of it
|
||||
## at the edge, times the charge's tier.
|
||||
## - Players take `damage`, armor first, credited to the thrower. The thrower takes
|
||||
## Tuning.BLAST_SELF_FACTOR of theirs. Everyone else takes it all: there are no
|
||||
## teammates in solo, and duos (M7) will apply one team rule to every weapon.
|
||||
## Tuning.BLAST_SELF_FACTOR of theirs. Everyone else takes it all, except the thrower's
|
||||
## teammates, who take none (Weapons.damage_player's team rule).
|
||||
## - Pieces and props take `structure_damage`. A breakwater is a piece, so a charge can
|
||||
## breach one and let the sea in.
|
||||
## Everything a blast reaches is worked out before any of it is applied, in ID order,
|
||||
|
||||
+32
-2
@@ -222,6 +222,7 @@ func step() -> void:
|
||||
DROP, PLAY:
|
||||
sim.step()
|
||||
_collect_damage()
|
||||
_collect_downs()
|
||||
_collect_eliminations()
|
||||
if phase == DROP and sim.drop.finished:
|
||||
_enter(PLAY)
|
||||
@@ -252,6 +253,7 @@ func _start() -> void:
|
||||
entity_of[handle] = entity_id
|
||||
handle_of[entity_id] = handle
|
||||
team_of[handle] = index / size
|
||||
sim.set_team(entity_id, index / size)
|
||||
stats[handle] = {"eliminations": 0, "damage_dealt": 0, "damage_taken": 0}
|
||||
_match_size = participants.size()
|
||||
_roster = participants.duplicate()
|
||||
@@ -279,6 +281,32 @@ func _collect_damage() -> void:
|
||||
_last_weapon[victim] = int(event.get("item", -1))
|
||||
|
||||
|
||||
## Reports downs and revives (M7) by handle: {"type": "downed", "handle", "by", "cause",
|
||||
## "item"} and {"type": "revived", "handle", "by"}. Downs also go in the kill feed, marked
|
||||
## "downed".
|
||||
func _collect_downs() -> void:
|
||||
for event: Dictionary in sim.events:
|
||||
if not handle_of.has(event.get("player", 0)):
|
||||
continue
|
||||
var handle: int = handle_of[event["player"]]
|
||||
if event["type"] == "downed":
|
||||
var by: int = int(handle_of.get(event["by"], 0))
|
||||
var record: Dictionary = {
|
||||
"type": "downed", "handle": handle, "by": by, "cause": String(event["cause"]),
|
||||
"item": int(_last_weapon.get(handle, -1)) if by != 0 else -1, "tick": sim.tick,
|
||||
}
|
||||
events.append(record)
|
||||
var entry: Dictionary = record.duplicate()
|
||||
entry.erase("type")
|
||||
entry["downed"] = true
|
||||
entry["place"] = 0
|
||||
entry["tied"] = false
|
||||
entry["left"] = false
|
||||
kill_feed.append(entry)
|
||||
elif event["type"] == "revived":
|
||||
events.append({"type": "revived", "handle": handle, "by": int(handle_of.get(event["by"], 0))})
|
||||
|
||||
|
||||
## Places everyone the simulation eliminated this tick. They share the best place of
|
||||
## the range they fall into: with five standing and two falling together, both are 4th.
|
||||
func _collect_eliminations() -> void:
|
||||
@@ -377,8 +405,8 @@ func _check_finished() -> void:
|
||||
events.append({"type": "match_ended", "match": current_seed(), "winners": winners.duplicate(), "timed_out": timed_out})
|
||||
|
||||
|
||||
## The best of `handles` by the tie-break: most health, then highest feet, then the
|
||||
## earliest to join. With `worst`, the worst instead.
|
||||
## The best of `handles` by the tie-break: standing over downed, most health, then
|
||||
## highest feet, then the earliest to join. With `worst`, the worst instead.
|
||||
func _tie_break(handles: Array[int], worst: bool = false) -> int:
|
||||
var chosen: int = handles[0]
|
||||
for handle: int in handles:
|
||||
@@ -393,6 +421,8 @@ func _tie_break(handles: Array[int], worst: bool = false) -> int:
|
||||
func _beats(a: int, b: int) -> bool:
|
||||
var pa: SimEntity = sim.entities.find(entity_of[a])
|
||||
var pb: SimEntity = sim.entities.find(entity_of[b])
|
||||
if pa.downed != pb.downed:
|
||||
return pb.downed
|
||||
if pa.health != pb.health:
|
||||
return pa.health > pb.health
|
||||
if not is_equal_approx(pa.position.y, pb.position.y):
|
||||
|
||||
@@ -21,6 +21,11 @@ static func step(player: SimEntity, command: PlayerCommand, ground: SimGround, s
|
||||
player.crouching = command.is_pressed(PlayerCommand.BUTTON_CROUCH)
|
||||
wants_jump = command.is_pressed(PlayerCommand.BUTTON_JUMP) and not player.crouching
|
||||
wish = _wish_velocity(command, player.crouching)
|
||||
if player.downed:
|
||||
# Downed (M7): low to the ground and crawling, with no jump or sprint.
|
||||
player.crouching = true
|
||||
wants_jump = false
|
||||
wish = wish.limit_length(Tuning.DOWNED_CRAWL_SPEED)
|
||||
|
||||
if player.drop_state == Drop.ABOARD:
|
||||
# Riders move with the barge; Simulation places them.
|
||||
@@ -228,6 +233,10 @@ static func _swim(player: SimEntity, command: PlayerCommand, ground: SimGround,
|
||||
speed = Tuning.SWIM_SPRINT_SPEED
|
||||
if not has_stamina:
|
||||
speed *= Tuning.SWIM_EXHAUSTED_FACTOR
|
||||
if player.downed:
|
||||
# A downed swimmer paddles at a crawl and can't dive.
|
||||
speed = minf(speed, Tuning.DOWNED_CRAWL_SPEED)
|
||||
diving = false
|
||||
var velocity: Vector3 = move * speed
|
||||
|
||||
var float_depth: float = Tuning.SWIM_FLOAT_DEPTH if has_stamina else Tuning.SWIM_EXHAUSTED_DEPTH
|
||||
|
||||
@@ -63,6 +63,14 @@ var prev_buttons: int = 0
|
||||
var view_quarters: int = 0
|
||||
## Set once health reaches 0. Eliminated players take no more commands.
|
||||
var eliminated: bool = false
|
||||
## The player's team, set by Match; -1 for none. Players on the same team can't hurt
|
||||
## each other, and a player with a teammate standing goes down instead of out (M7).
|
||||
var team: int = -1
|
||||
## Down but not out: crawling, bleeding health, waiting for a teammate. See Simulation.
|
||||
var downed: bool = false
|
||||
## Ticks a teammate has spent reviving this downed player without a break, and who.
|
||||
var revive_ticks: int = 0
|
||||
var reviver: int = 0
|
||||
## The player who last damaged this one, or 0.
|
||||
var last_attacker: int = 0
|
||||
## What dealt this player's most recent damage: one of the CAUSE_ constants. The cause
|
||||
|
||||
+137
-9
@@ -62,6 +62,8 @@ var _planned_levels: PackedFloat32Array = PackedFloat32Array()
|
||||
var _destroyed_checked: int = 0
|
||||
## Player entity IDs, ascending.
|
||||
var _players: Array[int] = []
|
||||
## Downed players someone worked on reviving this tick.
|
||||
var _tended: Dictionary = {}
|
||||
|
||||
|
||||
## Generates the island from the seed, unless `world` is given. Tests that don't care
|
||||
@@ -107,6 +109,51 @@ func add_player() -> int:
|
||||
return player.id
|
||||
|
||||
|
||||
## Puts a player on a team. Players on one team can't hurt each other, and go down
|
||||
## instead of out while a teammate stands (M7). Match sets every player's team.
|
||||
func set_team(player_id: int, team: int) -> void:
|
||||
var player: SimEntity = entities.find(player_id)
|
||||
if player != null:
|
||||
player.team = team
|
||||
|
||||
|
||||
## Whether `a` and `b` are different players on the same team.
|
||||
func are_teammates(a: SimEntity, b: SimEntity) -> bool:
|
||||
return a != null and b != null and a.id != b.id and a.team >= 0 and a.team == b.team
|
||||
|
||||
|
||||
## On their feet: in the match, not eliminated, not downed, health left.
|
||||
static func is_standing(player: SimEntity) -> bool:
|
||||
return player != null and not player.eliminated and not player.downed and player.health > 0
|
||||
|
||||
|
||||
## Whether any teammate of `player` is standing.
|
||||
func has_standing_teammate(player: SimEntity) -> bool:
|
||||
if player.team < 0:
|
||||
return false
|
||||
for other_id: int in _players:
|
||||
var other: SimEntity = entities.find(other_id)
|
||||
if are_teammates(player, other) and is_standing(other):
|
||||
return true
|
||||
return false
|
||||
|
||||
|
||||
## The nearest downed teammate within Tuning.REVIVE_RANGE of `player`, or null. Ties go
|
||||
## to the lower ID.
|
||||
func revivable_teammate(player: SimEntity) -> SimEntity:
|
||||
var best: SimEntity = null
|
||||
var best_distance: float = Tuning.REVIVE_RANGE * Tuning.REVIVE_RANGE
|
||||
for other_id: int in _players:
|
||||
var other: SimEntity = entities.find(other_id)
|
||||
if not are_teammates(player, other) or not other.downed or other.eliminated:
|
||||
continue
|
||||
var distance: float = player.position.distance_squared_to(other.position)
|
||||
if distance <= best_distance and (best == null or distance < best_distance):
|
||||
best = other
|
||||
best_distance = distance
|
||||
return best
|
||||
|
||||
|
||||
## Removes a player and any commands queued for it.
|
||||
func remove_player(player_id: int) -> void:
|
||||
entities.remove(player_id)
|
||||
@@ -204,6 +251,7 @@ func step() -> void:
|
||||
drop.ride(player, command, tick)
|
||||
else:
|
||||
_apply_command(player, command)
|
||||
_advance_downed()
|
||||
Weapons.advance_projectiles(self)
|
||||
_spill_broken_crates()
|
||||
_check_eliminations()
|
||||
@@ -220,12 +268,20 @@ func step() -> void:
|
||||
func _apply_command(player: SimEntity, command: PlayerCommand) -> void:
|
||||
var water: float = water_level_at(player.position)
|
||||
Movement.step(player, command, ground, water)
|
||||
var sprinting: bool = command != null and command.is_pressed(PlayerCommand.BUTTON_SPRINT)
|
||||
var sprinting: bool = command != null and command.is_pressed(PlayerCommand.BUTTON_SPRINT) and not player.downed
|
||||
Water.update(player, water_level_at(player.position), drown_dps, sprinting)
|
||||
if player.action_cooldown > 0:
|
||||
player.action_cooldown -= 1
|
||||
if command != null:
|
||||
Weapons.note_view(player, command, tick)
|
||||
if player.downed:
|
||||
# Crawling is all a downed player can do.
|
||||
player.prev_buttons = command.buttons if command != null else 0
|
||||
return
|
||||
if command != null and command.is_pressed(PlayerCommand.BUTTON_INTERACT) and _tend(player):
|
||||
# Reviving takes both hands: no looting, firing or building meanwhile.
|
||||
player.prev_buttons = command.buttons
|
||||
return
|
||||
Weapons.update(player)
|
||||
Consumables.update(self, player, command)
|
||||
var held: int = command.buttons if command != null else 0
|
||||
@@ -273,19 +329,87 @@ func _spill_broken_crates() -> void:
|
||||
events.append({"type": "crate_spilled", "prop": prop, "pickups": ids})
|
||||
|
||||
|
||||
## Marks players whose health reached 0 as eliminated, and drops what they carried.
|
||||
## A standing player holding interact works on reviving the nearest downed teammate in
|
||||
## range. Returns true if there was one. Revives on the REVIVE_SECONDS-th tick in a row.
|
||||
func _tend(player: SimEntity) -> bool:
|
||||
if player.drop_state != Drop.NONE or player.swimming:
|
||||
return false
|
||||
var patient: SimEntity = revivable_teammate(player)
|
||||
if patient == null:
|
||||
return false
|
||||
if patient.reviver != player.id:
|
||||
patient.revive_ticks = 0
|
||||
patient.reviver = player.id
|
||||
patient.revive_ticks += 1
|
||||
_tended[patient.id] = true
|
||||
if patient.revive_ticks >= roundi(Tuning.REVIVE_SECONDS * Tuning.TICK_RATE_HZ):
|
||||
patient.downed = false
|
||||
patient.health = Tuning.REVIVE_HEALTH
|
||||
patient.revive_ticks = 0
|
||||
patient.reviver = 0
|
||||
events.append({"type": "revived", "player": patient.id, "by": player.id})
|
||||
return true
|
||||
|
||||
|
||||
## Downed players bleed, and a revive nobody worked on this tick starts over.
|
||||
func _advance_downed() -> void:
|
||||
for player_id: int in _players:
|
||||
var player: SimEntity = entities.find(player_id)
|
||||
if not player.downed or player.eliminated:
|
||||
continue
|
||||
if not _tended.has(player_id):
|
||||
player.revive_ticks = 0
|
||||
player.reviver = 0
|
||||
if tick % Tuning.DOWNED_BLEED_INTERVAL_TICKS == 0:
|
||||
player.health = maxi(player.health - 1, 0)
|
||||
_tended.clear()
|
||||
|
||||
|
||||
## Players whose health reached 0 go down if a teammate is still standing, and are
|
||||
## eliminated otherwise, dropping what they carried. Downed players are eliminated once
|
||||
## their health runs out again, or once no teammate is left standing to revive them.
|
||||
## The blow that downed them is what eliminated them, credited to who struck it.
|
||||
func _check_eliminations() -> void:
|
||||
var out: Array[SimEntity] = []
|
||||
for player_id: int in _players:
|
||||
var player: SimEntity = entities.find(player_id)
|
||||
if player.eliminated or player.health > 0:
|
||||
continue
|
||||
player.eliminated = true
|
||||
player.velocity = Vector3.ZERO
|
||||
events.append({
|
||||
"type": "eliminated", "player": player_id, "by": player.last_attacker,
|
||||
"cause": SimEntity.CAUSE_NAMES[player.last_cause],
|
||||
})
|
||||
Inventory.drop_all(self, player)
|
||||
if not player.downed and player.drop_state == Drop.NONE and has_standing_teammate(player):
|
||||
player.downed = true
|
||||
player.health = Tuning.DOWNED_HEALTH
|
||||
player.armor = 0
|
||||
player.reload_ticks = 0
|
||||
player.use_ticks = 0
|
||||
player.revive_ticks = 0
|
||||
player.reviver = 0
|
||||
events.append({
|
||||
"type": "downed", "player": player_id, "by": player.last_attacker,
|
||||
"cause": SimEntity.CAUSE_NAMES[player.last_cause],
|
||||
})
|
||||
else:
|
||||
out.append(player)
|
||||
for player: SimEntity in out:
|
||||
_eliminate(player)
|
||||
# A downed player with nobody left to revive them is out.
|
||||
for player_id: int in _players:
|
||||
var player: SimEntity = entities.find(player_id)
|
||||
if player.downed and not player.eliminated and not has_standing_teammate(player):
|
||||
_eliminate(player)
|
||||
|
||||
|
||||
func _eliminate(player: SimEntity) -> void:
|
||||
player.eliminated = true
|
||||
player.health = 0
|
||||
player.velocity = Vector3.ZERO
|
||||
player.downed = false
|
||||
player.revive_ticks = 0
|
||||
player.reviver = 0
|
||||
events.append({
|
||||
"type": "eliminated", "player": player.id, "by": player.last_attacker,
|
||||
"cause": SimEntity.CAUSE_NAMES[player.last_cause],
|
||||
})
|
||||
Inventory.drop_all(self, player)
|
||||
|
||||
|
||||
## Moves the sea surface, and spreads the flood for it at once. Takes effect on the
|
||||
@@ -369,6 +493,10 @@ func state_hash() -> String:
|
||||
buffer.put_32(entity.prev_buttons)
|
||||
buffer.put_u8(1 if entity.eliminated else 0)
|
||||
buffer.put_64(entity.view_quarters)
|
||||
buffer.put_32(entity.team)
|
||||
buffer.put_u8(1 if entity.downed else 0)
|
||||
buffer.put_32(entity.revive_ticks)
|
||||
buffer.put_32(entity.reviver)
|
||||
buffer.put_32(entity.last_attacker)
|
||||
buffer.put_u8(entity.last_cause)
|
||||
buffer.put_32(entity.item)
|
||||
|
||||
@@ -58,6 +58,20 @@ const DUO_TEAMS: int = 12
|
||||
const DUO_TEAM_SIZE: int = 2
|
||||
const REVIVE_SECONDS: float = 6.0
|
||||
|
||||
# Duos: downed, revive and bleed-out (M7). See Simulation.
|
||||
## A player whose health runs out while a teammate is still standing goes down instead
|
||||
## of out, with this much health to bleed. Hits on a downed player take it, too.
|
||||
const DOWNED_HEALTH: int = 60
|
||||
## A downed player loses one health this often, so bleeding out takes 30 seconds.
|
||||
const DOWNED_BLEED_INTERVAL_TICKS: int = 15
|
||||
## Downed players crawl: no jumping, sprinting, firing, building or using items.
|
||||
const DOWNED_CRAWL_SPEED: float = 1.0
|
||||
## A standing teammate holding interact within this distance (feet to feet) revives a
|
||||
## downed one in REVIVE_SECONDS. Letting go or moving away starts it over.
|
||||
const REVIVE_RANGE: float = 2.0
|
||||
## Health a revived player gets up with.
|
||||
const REVIVE_HEALTH: int = 30
|
||||
|
||||
# Match flow, in seconds. See Match and MatchRules, which can override each one.
|
||||
## The lobby counts down once this many participants have joined.
|
||||
const MATCH_MIN_PLAYERS: int = 1
|
||||
@@ -265,6 +279,11 @@ const BOT_STUCK_REPATHS: int = 3
|
||||
## Each bot re-checks its remaining path against grid changes this often, in ticks.
|
||||
const BOT_PATH_CHECK_TICKS: int = 15
|
||||
|
||||
## Duos (M7): a bot goes to revive a downed teammate this close, unless it's in a fight.
|
||||
const BOT_REVIVE_METRES: float = 60.0
|
||||
## Duos: a roaming bot this far from its teammate heads back to them.
|
||||
const BOT_REGROUP_METRES: float = 30.0
|
||||
|
||||
# Bot brains. Bots loot, fight, heal and keep ahead of the tide with only what a player
|
||||
# would know: what they can see, the map's points of interest, and the tide forecast.
|
||||
## Per difficulty: `reaction` is seconds between first seeing an opponent and firing,
|
||||
|
||||
+5
-1
@@ -269,10 +269,14 @@ static func _pull(sim: Simulation, player: SimEntity, point: Vector3, speed: flo
|
||||
|
||||
|
||||
## Takes `amount` from armor, then health. Returns the damage actually done. `item` is
|
||||
## the weapon's item code, or -1, for the kill feed.
|
||||
## the weapon's item code, or -1, for the kill feed. Every weapon, the boathook and
|
||||
## blasts come through here, so this is the one team rule: nobody can hurt a teammate
|
||||
## (M7). Hurting yourself, as with your own keg, still counts.
|
||||
static func damage_player(sim: Simulation, victim: SimEntity, amount: int, attacker: int, headshot: bool = false, item: int = -1) -> int:
|
||||
if victim == null or victim.eliminated or amount <= 0:
|
||||
return 0
|
||||
if attacker != 0 and sim.are_teammates(victim, sim.entities.find(attacker)):
|
||||
return 0
|
||||
var to_armor: int = mini(victim.armor, amount)
|
||||
victim.armor -= to_armor
|
||||
var to_health: int = mini(victim.health, amount - to_armor)
|
||||
|
||||
+9
-2
@@ -9,7 +9,7 @@
|
||||
class_name Menus
|
||||
extends Control
|
||||
|
||||
signal practice_requested(bots: int, difficulty: int)
|
||||
signal practice_requested(bots: int, difficulty: int, team_size: int)
|
||||
signal join_requested(host: String, port: int, player_name: String)
|
||||
signal resume_requested
|
||||
signal leave_requested
|
||||
@@ -41,6 +41,7 @@ var _binding_note: Label
|
||||
## Practice.
|
||||
var _bots: SpinBox
|
||||
var _difficulty: OptionButton
|
||||
var _mode: OptionButton
|
||||
## Join.
|
||||
var _name: LineEdit
|
||||
var _address: LineEdit
|
||||
@@ -360,6 +361,10 @@ func _build_practice() -> void:
|
||||
for index: int in Tuning.BOT_DIFFICULTIES.size():
|
||||
_difficulty.add_item(String(Tuning.BOT_DIFFICULTIES[index]["name"]).capitalize(), index + 1)
|
||||
_row(column, "Bot skill", _difficulty)
|
||||
_mode = OptionButton.new()
|
||||
_mode.add_item("Solo", 1)
|
||||
_mode.add_item("Duos, with a bot crewmate", Tuning.DUO_TEAM_SIZE)
|
||||
_row(column, "Crew", _mode)
|
||||
_button(column, "Set out", _start_practice)
|
||||
_button(column, "Back", back)
|
||||
|
||||
@@ -367,8 +372,9 @@ func _build_practice() -> void:
|
||||
func _start_practice() -> void:
|
||||
settings.practice_bots = int(_bots.value)
|
||||
settings.practice_difficulty = _difficulty.selected - 1
|
||||
settings.practice_team_size = _mode.get_item_id(_mode.selected)
|
||||
save_settings()
|
||||
practice_requested.emit(settings.practice_bots, settings.practice_difficulty)
|
||||
practice_requested.emit(settings.practice_bots, settings.practice_difficulty, settings.practice_team_size)
|
||||
|
||||
|
||||
func _build_join() -> void:
|
||||
@@ -580,6 +586,7 @@ func _build_results() -> void:
|
||||
func _refresh_controls() -> void:
|
||||
_bots.value = settings.practice_bots
|
||||
_difficulty.selected = settings.practice_difficulty + 1
|
||||
_mode.selected = maxi(_mode.get_item_index(settings.practice_team_size), 0)
|
||||
_name.text = settings.player_name
|
||||
if _address.text.is_empty():
|
||||
_address.text = settings.last_server
|
||||
|
||||
+25
-4
@@ -18,11 +18,19 @@ static func tick_limit() -> int:
|
||||
## count from the barge leaving. Each group (M6) adds up its bots' BotBrain.stats and
|
||||
## holds their "bots", "places" and "wins".
|
||||
##
|
||||
## With `team_size` 2 the match is duos (M7), and the result also has "downs",
|
||||
## "revives", "team_hits" (hits that did damage between teammates, which must be 0) and
|
||||
## "winner_teams" (how many teams the winners came from, which must be 1).
|
||||
##
|
||||
## With `split_builders`, only every other bot gathers and builds; the rest are the
|
||||
## control group. Bot difficulty also goes by turns of three, so both groups have each
|
||||
## level equally (within one bot).
|
||||
static func run_match(seed_value: int, bots: int = Tuning.SOLO_PLAYERS, difficulty: int = -1, split_builders: bool = false) -> Dictionary:
|
||||
var loop: ServerLoop = ServerLoop.new(seed_value, 0, bots, null, difficulty)
|
||||
static func run_match(seed_value: int, bots: int = Tuning.SOLO_PLAYERS, difficulty: int = -1, split_builders: bool = false, team_size: int = 1) -> Dictionary:
|
||||
var rules: MatchRules = null
|
||||
if team_size > 1:
|
||||
rules = ServerLoop.immediate_rules(0, bots)
|
||||
rules.team_size = team_size
|
||||
var loop: ServerLoop = ServerLoop.new(seed_value, 0, bots, rules, difficulty)
|
||||
var flow: Match = loop.match_flow
|
||||
var level_of: Dictionary = {}
|
||||
for bot: BotBrain in loop.bots:
|
||||
@@ -31,6 +39,7 @@ static func run_match(seed_value: int, bots: int = Tuning.SOLO_PLAYERS, difficul
|
||||
"seed": seed_value, "finished": false, "winner": 0, "winner_difficulty": "",
|
||||
"timed_out": false, "causes": {}, "places": {}, "eliminations": {}, "shots": 0,
|
||||
"slow_ticks": [], "weapon_kills": {}, "death_seconds": [],
|
||||
"downs": 0, "revives": 0, "team_hits": 0, "winner_teams": 0,
|
||||
}
|
||||
var limit: int = tick_limit()
|
||||
var split: bool = false
|
||||
@@ -45,13 +54,25 @@ static func run_match(seed_value: int, bots: int = Tuning.SOLO_PLAYERS, difficul
|
||||
if Time.get_ticks_usec() - before > ServerLoop.TICK_BUDGET_USEC:
|
||||
result["slow_ticks"].append(loop.sim.tick)
|
||||
for event: Dictionary in loop.sim.events:
|
||||
if event["type"] == "shot":
|
||||
result["shots"] += 1
|
||||
match String(event["type"]):
|
||||
"shot":
|
||||
result["shots"] += 1
|
||||
"downed":
|
||||
result["downs"] += 1
|
||||
"revived":
|
||||
result["revives"] += 1
|
||||
"player_hit":
|
||||
if int(event["armor"]) + int(event["health"]) > 0 and loop.sim.are_teammates(loop.sim.entities.find(int(event["victim"])), loop.sim.entities.find(int(event["player"]))):
|
||||
result["team_hits"] += 1
|
||||
for event: Dictionary in flow.events:
|
||||
if event["type"] == "match_ended":
|
||||
result["timed_out"] = event["timed_out"]
|
||||
result["ticks"] = loop.sim.tick
|
||||
result["finished"] = flow.phase == Match.RESULTS
|
||||
var winner_teams: Dictionary = {}
|
||||
for handle: int in flow.winners:
|
||||
winner_teams[flow.team_of[handle]] = true
|
||||
result["winner_teams"] = winner_teams.size()
|
||||
if flow.winners.size() > 0:
|
||||
result["winner"] = flow.winners[0]
|
||||
result["winner_difficulty"] = level_of.get(flow.winners[0], "")
|
||||
|
||||
@@ -446,3 +446,66 @@ func test_a_bot_with_nothing_to_do_holds_its_ground() -> void:
|
||||
_run(roundi(Tuning.BOT_HOLD_SECONDS * 0.8) * TICKS)
|
||||
assert_true(me.position.distance_to(at) < 3.0, "and stays put while holding (moved %.1f m)" % me.position.distance_to(at))
|
||||
assert_true(at.distance_to(HOME) <= Tuning.BOT_ROAM_METRES + 5.0, "it didn't roam far (%.1f m)" % at.distance_to(HOME))
|
||||
|
||||
|
||||
# Duos (M7): bots as teammates.
|
||||
|
||||
func test_bots_never_target_or_shoot_a_teammate() -> void:
|
||||
_setup()
|
||||
var brain: BotBrain = _bot(HOME, BotBrain.HARD)
|
||||
var me: SimEntity = sim.entities.find(brain.player_id)
|
||||
_arm(me)
|
||||
var mate: SimEntity = _player(HOME + Vector3(8.0, 0.0, 0.0))
|
||||
sim.set_team(me.id, 0)
|
||||
sim.set_team(mate.id, 0)
|
||||
_ready_world()
|
||||
_pin(brain)
|
||||
_run(3 * TICKS)
|
||||
assert_eq(brain.target_id, 0, "a teammate in plain view isn't a target")
|
||||
assert_eq(int(shots_by.get(me.id, 0)), 0)
|
||||
assert_eq(mate.health, Tuning.PLAYER_MAX_HEALTH)
|
||||
|
||||
|
||||
func test_a_bot_goes_to_a_downed_teammate_and_revives_them() -> void:
|
||||
_setup()
|
||||
var brain: BotBrain = _bot(HOME)
|
||||
var me: SimEntity = sim.entities.find(brain.player_id)
|
||||
_arm(me)
|
||||
var mate: SimEntity = _player(HOME + Vector3(12.0, 0.0, 6.0))
|
||||
sim.set_team(me.id, 0)
|
||||
sim.set_team(mate.id, 0)
|
||||
_ready_world()
|
||||
mate.health = 0
|
||||
_run(1)
|
||||
assert_true(mate.downed)
|
||||
var revived: Array[bool] = [false]
|
||||
var states: Dictionary = {}
|
||||
_run(20 * TICKS, func() -> bool:
|
||||
states[brain.state] = true
|
||||
for event: Dictionary in sim.events:
|
||||
if event["type"] == "revived" and event["by"] == me.id:
|
||||
revived[0] = true
|
||||
return revived[0])
|
||||
assert_true(states.has("revive"), "states: %s" % [states.keys()])
|
||||
assert_true(revived[0], "revived within 20 s (mate downed: %s, %.1f m apart)" % [mate.downed, me.position.distance_to(mate.position)])
|
||||
assert_false(mate.downed)
|
||||
assert_true(Simulation.is_standing(mate))
|
||||
|
||||
|
||||
func test_a_downed_bot_crawls_toward_its_standing_teammate() -> void:
|
||||
_setup()
|
||||
var brain: BotBrain = _bot(HOME)
|
||||
var me: SimEntity = sim.entities.find(brain.player_id)
|
||||
var mate: SimEntity = _player(HOME + Vector3(10.0, 0.0, 0.0))
|
||||
sim.set_team(me.id, 0)
|
||||
sim.set_team(mate.id, 0)
|
||||
_ready_world()
|
||||
me.health = 0
|
||||
_run(1)
|
||||
assert_true(me.downed)
|
||||
var before: float = me.position.distance_to(mate.position)
|
||||
_run(3 * TICKS)
|
||||
assert_eq(brain.state, "downed")
|
||||
var after: float = me.position.distance_to(mate.position)
|
||||
assert_near(before - after, 3.0 * Tuning.DOWNED_CRAWL_SPEED, 0.5, "crawled toward the teammate")
|
||||
assert_eq(int(shots_by.get(me.id, 0)), 0)
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
[gd_scene load_steps=2 format=3]
|
||||
|
||||
[ext_resource type="Script" path="res://test/capture/client_scene.gd" id="1"]
|
||||
|
||||
[node name="CaptureClient" type="Node3D"]
|
||||
script = ExtResource("1")
|
||||
stage = "hud_downed"
|
||||
@@ -12,7 +12,9 @@
|
||||
## hud and hud_build (issue A9): once landed, the server hands the player a carbine, a
|
||||
## fowling piece and bandages, wounds them a little and takes three bots out in
|
||||
## different ways, so every part of the HUD has something to show; hud_build then goes
|
||||
## into build mode. Every stage draws the HUD as the client's HudState has it.
|
||||
## into build mode. hud_downed (issue M7) plays duos, with the first bot as the player's
|
||||
## crewmate, and after the hud staging a bot's shot downs the player. Every stage draws
|
||||
## the HUD as the client's HudState has it.
|
||||
extends Node3D
|
||||
|
||||
const DT: float = 1.0 / Tuning.TICK_RATE_HZ
|
||||
@@ -34,6 +36,8 @@ func _ready() -> void:
|
||||
rules.max_players = bots + 1
|
||||
rules.lobby_ticks = 6
|
||||
rules.countdown_ticks = 6
|
||||
if stage == "hud_downed":
|
||||
rules.team_size = Tuning.DUO_TEAM_SIZE
|
||||
_loop = ServerLoop.new(match_seed, 0, bots, rules)
|
||||
_net = NetServer.new()
|
||||
if _net.listen(0, HOST) != OK:
|
||||
@@ -68,7 +72,7 @@ func _ready() -> void:
|
||||
reached = me.drop_state == Drop.ABOARD and _session.game.prediction.next_tick > 3 * Tuning.TICK_RATE_HZ
|
||||
"glide":
|
||||
reached = me.drop_state == Drop.GLIDING
|
||||
"landed", "basin", "build", "build_refused", "hud", "hud_build":
|
||||
"landed", "basin", "build", "build_refused", "hud", "hud_build", "hud_downed":
|
||||
reached = me.drop_state == Drop.NONE
|
||||
if reached and since < 0:
|
||||
since = 0
|
||||
@@ -94,6 +98,11 @@ func _ready() -> void:
|
||||
return
|
||||
if stage == "hud_build" and _build_mode(true).is_empty():
|
||||
return
|
||||
if stage == "hud_downed":
|
||||
var downed_text: String = _down_player()
|
||||
if downed_text.is_empty():
|
||||
return
|
||||
basin_text += downed_text
|
||||
_session.hud.fade_feed = false
|
||||
_session.hud.show_state(_session.hud_state())
|
||||
_session.view.settle()
|
||||
@@ -139,7 +148,7 @@ func _stage_hud() -> String:
|
||||
var taken: int = 0
|
||||
for bot: int in flow.bot_handles.keys():
|
||||
var player: SimEntity = sim.entities.find(int(flow.entity_of.get(bot, 0)))
|
||||
if player == null or player.eliminated:
|
||||
if player == null or player.eliminated or sim.are_teammates(mine, player):
|
||||
continue
|
||||
player.health = 0
|
||||
player.last_cause = causes[taken]
|
||||
@@ -164,6 +173,35 @@ func _stage_hud() -> String:
|
||||
return " · %d of %d standing, %d feed lines" % [hud.standing, hud.total, hud.feed.size()]
|
||||
|
||||
|
||||
## Duos: a bot's shot takes the player's last health with their crewmate still up, so
|
||||
## they go down. Returns a caption line, or "" after reporting an error.
|
||||
func _down_player() -> String:
|
||||
var flow: Match = _loop.match_flow
|
||||
var sim: Simulation = _loop.sim
|
||||
var mine: SimEntity = sim.entities.find(int(flow.entity_of.get(_session.link.handle, 0)))
|
||||
var foe: SimEntity = null
|
||||
for bot: int in flow.bot_handles.keys():
|
||||
var player: SimEntity = sim.entities.find(int(flow.entity_of.get(bot, 0)))
|
||||
if player != null and not player.eliminated and not sim.are_teammates(mine, player):
|
||||
foe = player
|
||||
break
|
||||
if mine == null or foe == null or not sim.has_standing_teammate(mine):
|
||||
push_error("client capture: no foe, or no crewmate standing, to down the player")
|
||||
return ""
|
||||
mine.armor = 0
|
||||
Weapons.damage_player(sim, mine, mine.health, foe.id, false, ItemCatalog.code_of("dock_carbine"))
|
||||
for _round: int in Tuning.TICK_RATE_HZ:
|
||||
_game.poll()
|
||||
_loop.run_tick()
|
||||
_game.after_tick()
|
||||
_session.pump(DT)
|
||||
var hud: HudState = _session.hud_state()
|
||||
if not mine.downed or not hud.downed:
|
||||
push_error("client capture: the player isn't down (server %s, HUD %s)" % [mine.downed, hud.downed])
|
||||
return ""
|
||||
return " · downed, %d health to bleed" % mine.health
|
||||
|
||||
|
||||
## Stops the autoplay where the player stands and goes into build mode for a driftwood
|
||||
## wall, after the server has given the player plenty of materials or taken them all.
|
||||
## Returns a caption line, or "" after reporting an error.
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
## animation, seen from in front and to their right:
|
||||
##
|
||||
## - states: idle, walk, run, crouched, creeping, in the air, skydiving, gliding,
|
||||
## swimming. (Aboard the barge is the idle with the feet set wider; the deck
|
||||
## swimming, downed (M7). (Aboard the barge is the idle with the feet set wider; the deck
|
||||
## placement would pull it out of the row.)
|
||||
## - actions: carrying a longgun, a revolver and a tonic, firing each kind, a boathook
|
||||
## swing, a keg thrown, building, reloading, drinking and a flinch.
|
||||
@@ -24,6 +24,7 @@ const STATES: Array = [
|
||||
["skydive", "", "skydive", 0.8, ""],
|
||||
["glide", "", "glide", 0.8, ""],
|
||||
["swim", "", "swim", 0.35, ""],
|
||||
["downed", "", "downed", 0.5, ""],
|
||||
]
|
||||
const ACTIONS: Array = [
|
||||
["long", "whalers_longgun", "ground", 0.6, ""],
|
||||
@@ -114,6 +115,10 @@ func _stand(at: Vector3, row: Array) -> SimEntity:
|
||||
"swim":
|
||||
player.swimming = true
|
||||
player.on_ground = false
|
||||
"downed":
|
||||
player.downed = true
|
||||
player.crouching = true
|
||||
player.health = Tuning.DOWNED_HEALTH
|
||||
"aboard":
|
||||
player.drop_state = Drop.ABOARD
|
||||
player.on_ground = false
|
||||
|
||||
@@ -87,7 +87,11 @@ func test_states_follow_the_replicated_flags() -> void:
|
||||
player.crouching = true
|
||||
assert_eq(FigureRig.state_of(player, false), "crouch")
|
||||
assert_eq(FigureRig.state_of(player, true), "air")
|
||||
player.downed = true
|
||||
assert_eq(FigureRig.state_of(player, true), "downed", "M7: down on hands and knees")
|
||||
player.swimming = true
|
||||
assert_eq(FigureRig.state_of(player, true), "swim", "a downed swimmer still swims")
|
||||
player.downed = false
|
||||
assert_eq(FigureRig.state_of(player, true), "swim")
|
||||
for drop: Array in [[Drop.ABOARD, "aboard"], [Drop.FREEFALL, "skydive"], [Drop.GLIDING, "glide"]]:
|
||||
player.drop_state = drop[0]
|
||||
|
||||
@@ -201,3 +201,16 @@ func _texts(node: Node) -> Array[String]:
|
||||
for child: Node in node.get_children():
|
||||
found.append_array(_texts(child))
|
||||
return found
|
||||
|
||||
|
||||
func test_a_down_in_duos_travels_in_the_feed_and_reads_as_a_down() -> void:
|
||||
var entries: Array[Dictionary] = [
|
||||
{"victim": -3, "by": 1, "cause": "weapon", "item": -1, "place": 0, "tied": false, "downed": true, "victim_name": "Thole", "by_name": "Ada"},
|
||||
{"victim": -4, "by": 0, "cause": "fall", "item": -1, "place": 0, "tied": false, "downed": true, "victim_name": "Brine", "by_name": ""},
|
||||
]
|
||||
var told: Dictionary = NetFeed.decode(NetFeed.encode(3, 24, entries))
|
||||
assert_true(told["entries"][0]["downed"])
|
||||
var lines: Array[Dictionary] = HudState.feed_lines(told["entries"], 1)
|
||||
assert_eq(lines[0]["text"], "You knocked Thole down")
|
||||
assert_eq(lines[1]["text"], "Brine is down")
|
||||
assert_eq(HudState.feed_lines(told["entries"], -3)[0]["text"], "Ada knocked you down")
|
||||
|
||||
@@ -165,6 +165,7 @@ func test_the_own_block_round_trips_exactly() -> void:
|
||||
assert_eq(copy.stamina_ticks, 1234)
|
||||
assert_true(copy.swimming and not copy.on_ground)
|
||||
assert_eq(copy.drop_state, Drop.GLIDING)
|
||||
assert_false(copy.downed)
|
||||
assert_eq(back["self"]["water"], own["water"])
|
||||
assert_eq(back["self"]["water_mask"], 0b101010101)
|
||||
for length: int in bytes.size():
|
||||
@@ -176,3 +177,25 @@ func test_the_own_block_round_trips_exactly() -> void:
|
||||
assert_true(NetSnapshot.decode_snapshot(poisoned).is_empty(), "a NaN position")
|
||||
poisoned.encode_float(at, INF)
|
||||
assert_true(NetSnapshot.decode_snapshot(poisoned).is_empty(), "an infinite position")
|
||||
|
||||
|
||||
func test_downed_travels_in_the_record_and_the_own_block() -> void:
|
||||
var sim: Simulation = Simulation.new(3, SimGround.flat())
|
||||
var player: SimEntity = _player(sim, Vector3(100.0, 0.0, 100.0))
|
||||
player.downed = true
|
||||
player.crouching = true
|
||||
player.reload_ticks = 3
|
||||
var record: PackedInt32Array = NetSnapshot.record_of(player)
|
||||
assert_true(record[NetSnapshot.R_FLAGS] & NetSnapshot.FLAG_DOWNED != 0)
|
||||
var own: Dictionary = NetSnapshot.self_of(player, 0.0, 0)
|
||||
var bytes: PackedByteArray = NetSnapshot.encode_snapshot({"tick": 2, "sim_tick": 2, "own_id": player.id, "self": own}, PackedInt32Array(), [[player.id, NetSnapshot.full_mask(SimEntity.ARCHETYPE_PLAYER), record]])
|
||||
var back: Dictionary = NetSnapshot.decode_snapshot(bytes)
|
||||
assert_false(back.is_empty())
|
||||
var merged: PackedInt32Array = NetSnapshot.merge_record(PackedInt32Array(), SimEntity.ARCHETYPE_PLAYER, back["records"][0][2], back["records"][0][3])
|
||||
assert_eq(merged, record)
|
||||
var flags: int = merged[NetSnapshot.R_FLAGS]
|
||||
assert_true(flags & NetSnapshot.FLAG_DOWNED != 0, "in the record")
|
||||
assert_true(flags & NetSnapshot.FLAG_RELOADING != 0, "the low byte is still there")
|
||||
var copy: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
|
||||
NetSnapshot.apply_self(copy, back["self"])
|
||||
assert_true(copy.downed, "in the own block, so prediction crawls too")
|
||||
|
||||
@@ -153,3 +153,13 @@ func test_health_and_stop_options() -> void:
|
||||
assert_eq([config.health_port, config.health_bind, config.stop_file], [8080, "0.0.0.0", "/tmp/x"])
|
||||
assert_false(_parse(["--server", "--health-bind=localhost"]).is_valid())
|
||||
assert_false(_parse(["--server", "--health-port=70000"]).is_valid())
|
||||
|
||||
|
||||
func test_team_size_picks_solo_or_duos() -> void:
|
||||
assert_eq(_parse(["--server"]).team_size, 1, "solo by default")
|
||||
var duos: ServerConfig = _parse(["--server", "--team-size=2", "--bots=23", "--players=1"])
|
||||
assert_true(duos.is_valid(), str(duos.errors))
|
||||
assert_eq(duos.team_size, Tuning.DUO_TEAM_SIZE)
|
||||
assert_eq(duos.to_dictionary()["team_size"], 2)
|
||||
for bad: String in ["--team-size=0", "--team-size=3", "--team-size=two"]:
|
||||
assert_false(_parse(["--server", bad]).is_valid(), bad)
|
||||
|
||||
@@ -0,0 +1,331 @@
|
||||
extends TestCase
|
||||
|
||||
## Duos from issue M7: going down instead of out while a teammate stands, crawling,
|
||||
## revives, bleeding out, a team eliminated when both are out, no friendly damage, and
|
||||
## team placement in a match.
|
||||
|
||||
const FEET: Vector3 = Vector3(100.0, 0.0, 100.0)
|
||||
const REVIVE_TICKS: int = roundi(Tuning.REVIVE_SECONDS * Tuning.TICK_RATE_HZ)
|
||||
|
||||
|
||||
## A flat world with four players in a row 1 m apart, facing +z: 1 and 2 on team 0,
|
||||
## 3 and 4 on team 1.
|
||||
func _sim() -> Simulation:
|
||||
var sim: Simulation = Simulation.new(77, SimGround.flat())
|
||||
for index: int in 4:
|
||||
var player: SimEntity = sim.entities.find(sim.add_player())
|
||||
player.position = FEET + Vector3(index * 1.0, 0.0, 0.0)
|
||||
player.on_ground = true
|
||||
sim.set_team(player.id, index / 2)
|
||||
return sim
|
||||
|
||||
|
||||
func _p(sim: Simulation, id: int) -> SimEntity:
|
||||
return sim.entities.find(id)
|
||||
|
||||
|
||||
## Steps once, with `buttons` and `move` for the players in `held`, and nothing else.
|
||||
func _step(sim: Simulation, held: Dictionary = {}, move: Vector2 = Vector2.ZERO) -> void:
|
||||
for id: int in [1, 2, 3, 4]:
|
||||
if not sim.entities.contains(id):
|
||||
continue
|
||||
var buttons: int = int(held.get(id, 0))
|
||||
var player: SimEntity = _p(sim, id)
|
||||
sim.submit_command(id, PlayerCommand.from_input(sim.tick, move if held.has(id) else Vector2.ZERO, 0.0, 0.0, buttons, player.selected))
|
||||
sim.step()
|
||||
|
||||
|
||||
func _events(sim: Simulation, kind: String) -> Array[Dictionary]:
|
||||
var found: Array[Dictionary] = []
|
||||
for event: Dictionary in sim.events:
|
||||
if event["type"] == kind:
|
||||
found.append(event)
|
||||
return found
|
||||
|
||||
|
||||
## Lands a lethal hit on `victim` from `attacker`, then steps.
|
||||
func _knock(sim: Simulation, victim: int, attacker: int) -> void:
|
||||
_p(sim, victim).health = 5
|
||||
_p(sim, victim).armor = 0
|
||||
assert_eq(Weapons.damage_player(sim, _p(sim, victim), 50, attacker), 5)
|
||||
_step(sim)
|
||||
|
||||
|
||||
func test_a_lethal_hit_downs_a_player_whose_teammate_stands() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
var downed: SimEntity = _p(sim, 1)
|
||||
assert_true(downed.downed, "down, not out")
|
||||
assert_false(downed.eliminated)
|
||||
assert_eq(downed.health, Tuning.DOWNED_HEALTH)
|
||||
var events: Array[Dictionary] = _events(sim, "downed")
|
||||
assert_eq(events.size(), 1)
|
||||
assert_eq(events[0]["player"], 1)
|
||||
assert_eq(events[0]["by"], 3)
|
||||
assert_eq(_events(sim, "eliminated").size(), 0)
|
||||
|
||||
|
||||
func test_a_player_with_no_team_or_no_teammate_standing_is_eliminated_outright() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
sim.set_team(1, -1)
|
||||
_knock(sim, 1, 3)
|
||||
assert_true(_p(sim, 1).eliminated, "no team: out")
|
||||
assert_false(_p(sim, 1).downed)
|
||||
# Player 2's teammate is out, so 2 has nobody to wait for either.
|
||||
_knock(sim, 2, 3)
|
||||
assert_true(_p(sim, 2).eliminated)
|
||||
|
||||
|
||||
func test_downed_players_crawl_and_cannot_fire_build_or_loot() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
Inventory.give(_p(sim, 1), ItemCatalog.code_of("dock_carbine"), 1)
|
||||
Inventory.give(_p(sim, 1), ItemCatalog.get_def(ItemCatalog.code_of("dock_carbine")).ammo_code, 20)
|
||||
_p(sim, 1).selected = 1
|
||||
_knock(sim, 1, 3)
|
||||
var start: Vector3 = _p(sim, 1).position
|
||||
var shots: int = 0
|
||||
for _tick: int in Tuning.TICK_RATE_HZ:
|
||||
_step(sim, {1: PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_SPRINT | PlayerCommand.BUTTON_JUMP}, Vector2(0.0, 1.0))
|
||||
shots += _events(sim, "shot").size()
|
||||
assert_true(_p(sim, 1).on_ground, "no jumping")
|
||||
assert_eq(shots, 0, "no firing")
|
||||
var crawled: float = _p(sim, 1).position.distance_to(start)
|
||||
assert_near(crawled, Tuning.DOWNED_CRAWL_SPEED, 0.1, "a second of crawling, sprint held")
|
||||
assert_true(_p(sim, 1).crouching, "low to the ground")
|
||||
_step(sim, {1: PlayerCommand.BUTTON_FIRE | PlayerCommand.BUTTON_BUILD})
|
||||
assert_eq(sim.structures.pieces.size(), 0, "no building")
|
||||
|
||||
|
||||
func test_a_teammate_holding_interact_revives_after_the_revive_time() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
for _tick: int in REVIVE_TICKS - 1:
|
||||
_step(sim, {2: PlayerCommand.BUTTON_INTERACT})
|
||||
assert_true(_p(sim, 1).downed)
|
||||
assert_eq(_p(sim, 1).revive_ticks, REVIVE_TICKS - 1)
|
||||
assert_eq(_p(sim, 1).reviver, 2)
|
||||
_step(sim, {2: PlayerCommand.BUTTON_INTERACT})
|
||||
assert_false(_p(sim, 1).downed, "back up")
|
||||
assert_eq(_p(sim, 1).health, Tuning.REVIVE_HEALTH)
|
||||
var revived: Array[Dictionary] = _events(sim, "revived")
|
||||
assert_eq(revived.size(), 1)
|
||||
assert_eq(revived[0]["by"], 2)
|
||||
|
||||
|
||||
func test_letting_go_or_moving_away_starts_the_revive_over() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
for _tick: int in 60:
|
||||
_step(sim, {2: PlayerCommand.BUTTON_INTERACT})
|
||||
_step(sim)
|
||||
assert_eq(_p(sim, 1).revive_ticks, 0, "let go")
|
||||
_p(sim, 2).position = _p(sim, 1).position + Vector3(Tuning.REVIVE_RANGE + 0.5, 0.0, 0.0)
|
||||
for _tick: int in REVIVE_TICKS + 5:
|
||||
_step(sim, {2: PlayerCommand.BUTTON_INTERACT})
|
||||
assert_true(_p(sim, 1).downed, "out of reach")
|
||||
assert_eq(_p(sim, 1).revive_ticks, 0)
|
||||
|
||||
|
||||
func test_an_opponent_cannot_revive_and_a_downed_player_cannot_revive() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
_knock(sim, 4, 2)
|
||||
for _tick: int in REVIVE_TICKS + 5:
|
||||
_step(sim, {3: PlayerCommand.BUTTON_INTERACT, 4: PlayerCommand.BUTTON_INTERACT})
|
||||
assert_true(_p(sim, 1).downed, "3 is an opponent")
|
||||
assert_true(_p(sim, 3).health > 0 and not _p(sim, 3).downed)
|
||||
|
||||
|
||||
func test_a_downed_player_bleeds_out_credited_to_who_downed_them() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
var ticks: int = 0
|
||||
while not _p(sim, 1).eliminated and ticks < 2000:
|
||||
_step(sim)
|
||||
ticks += 1
|
||||
assert_true(_p(sim, 1).eliminated)
|
||||
assert_near(ticks, Tuning.DOWNED_HEALTH * Tuning.DOWNED_BLEED_INTERVAL_TICKS, Tuning.DOWNED_BLEED_INTERVAL_TICKS, "about 30 s")
|
||||
var out: Array[Dictionary] = _events(sim, "eliminated")
|
||||
assert_eq(out.size(), 1)
|
||||
assert_eq(out[0]["by"], 3)
|
||||
assert_eq(out[0]["cause"], "weapon")
|
||||
|
||||
|
||||
func test_hits_on_a_downed_player_finish_them() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
Weapons.damage_player(sim, _p(sim, 1), Tuning.DOWNED_HEALTH, 4)
|
||||
_step(sim)
|
||||
assert_true(_p(sim, 1).eliminated)
|
||||
assert_eq(_events(sim, "eliminated")[0]["by"], 4)
|
||||
|
||||
|
||||
func test_the_team_is_out_when_both_are_down_or_out() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
assert_true(_p(sim, 1).downed)
|
||||
_knock(sim, 2, 4)
|
||||
assert_true(_p(sim, 2).eliminated, "nobody left to down for")
|
||||
assert_true(_p(sim, 1).eliminated, "and nobody left to revive 1")
|
||||
assert_eq(_events(sim, "eliminated").size(), 2)
|
||||
var credited: Dictionary = {}
|
||||
for event: Dictionary in _events(sim, "eliminated"):
|
||||
credited[event["player"]] = event["by"]
|
||||
assert_eq(credited, {1: 3, 2: 4})
|
||||
|
||||
|
||||
func test_teammates_falling_together_are_both_out() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_p(sim, 1).health = 0
|
||||
_p(sim, 2).health = 0
|
||||
_step(sim)
|
||||
assert_true(_p(sim, 1).eliminated and _p(sim, 2).eliminated)
|
||||
assert_false(_p(sim, 1).downed or _p(sim, 2).downed)
|
||||
|
||||
|
||||
func test_no_friendly_damage_from_any_weapon() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
assert_eq(Weapons.damage_player(sim, _p(sim, 2), 30, 1), 0, "teammate")
|
||||
assert_eq(_p(sim, 2).health, Tuning.PLAYER_MAX_HEALTH)
|
||||
assert_eq(Weapons.damage_player(sim, _p(sim, 3), 30, 1), 30, "opponent")
|
||||
assert_eq(Weapons.damage_player(sim, _p(sim, 1), 10, 1), 10, "yourself, as with your own keg")
|
||||
# A keg thrown into the team: the teammate beside the blast takes nothing.
|
||||
var keg: int = ItemCatalog.code_of("powder_keg")
|
||||
var def: ItemDef = ItemCatalog.get_def(keg)
|
||||
var before: int = _p(sim, 2).health
|
||||
Explosives.blast(sim, 1, def, 0, _p(sim, 2).position + Vector3(0.0, 0.3, 0.0))
|
||||
assert_eq(_p(sim, 2).health, before, "no blast damage to a teammate")
|
||||
assert_true(_p(sim, 3).health < Tuning.PLAYER_MAX_HEALTH - 30, "the opponent a metre further on is hurt")
|
||||
|
||||
|
||||
func test_a_downed_player_in_the_sea_still_drowns() -> void:
|
||||
var sim: Simulation = _sim()
|
||||
_knock(sim, 1, 3)
|
||||
sim.set_sea_level(5.0)
|
||||
for _tick: int in 3:
|
||||
_step(sim)
|
||||
assert_true(_p(sim, 1).swimming)
|
||||
var ticks: int = 0
|
||||
while not _p(sim, 1).eliminated and ticks < 1200:
|
||||
_step(sim)
|
||||
ticks += 1
|
||||
assert_true(_p(sim, 1).eliminated, "drowning takes the downed health")
|
||||
assert_true(ticks < Tuning.DOWNED_HEALTH * Tuning.DOWNED_BLEED_INTERVAL_TICKS, "sooner than bleeding out")
|
||||
|
||||
|
||||
func test_the_hash_tells_downed_and_revive_progress_apart() -> void:
|
||||
var a: Simulation = _sim()
|
||||
var b: Simulation = _sim()
|
||||
assert_eq(a.state_hash(), b.state_hash())
|
||||
_p(a, 1).downed = true
|
||||
assert_ne(a.state_hash(), b.state_hash())
|
||||
_p(b, 1).downed = true
|
||||
_p(b, 1).revive_ticks = 3
|
||||
assert_ne(a.state_hash(), b.state_hash())
|
||||
|
||||
|
||||
# Match: team placement.
|
||||
|
||||
func _rules() -> MatchRules:
|
||||
var rules: MatchRules = MatchRules.immediate()
|
||||
rules.max_players = 6
|
||||
rules.results_ticks = 2
|
||||
rules.team_size = Tuning.DUO_TEAM_SIZE
|
||||
return rules
|
||||
|
||||
|
||||
func _duos_match() -> Match:
|
||||
var m: Match = Match.new(4242, _rules())
|
||||
m.sim = Simulation.new(4242, SimGround.flat(20.0))
|
||||
m.join(1)
|
||||
m.step()
|
||||
assert_eq(m.phase, Match.DROP)
|
||||
var index: int = 0
|
||||
for handle: int in m.participants:
|
||||
var player: SimEntity = m.sim.entities.find(m.entity_of[handle])
|
||||
player.drop_state = Drop.NONE
|
||||
player.position = Vector3(100.0 + index * 4.0, 20.0, 100.0)
|
||||
player.velocity = Vector3.ZERO
|
||||
player.on_ground = true
|
||||
index += 1
|
||||
m.sim.drop.finished = true
|
||||
m.step()
|
||||
assert_eq(m.phase, Match.PLAY)
|
||||
return m
|
||||
|
||||
|
||||
func _mp(m: Match, handle: int) -> SimEntity:
|
||||
return m.sim.entities.find(m.entity_of[handle])
|
||||
|
||||
|
||||
func _place_of(m: Match, handle: int) -> int:
|
||||
for record: Dictionary in m.placements:
|
||||
if record["handle"] == handle:
|
||||
return int(record["place"])
|
||||
return 0
|
||||
|
||||
|
||||
func test_match_puts_each_pair_on_a_team_in_the_simulation() -> void:
|
||||
var m: Match = _duos_match()
|
||||
var hs: Array[int] = m.participants.duplicate()
|
||||
assert_eq(hs.size(), 6)
|
||||
for index: int in hs.size():
|
||||
assert_eq(m.team_of[hs[index]], index / 2)
|
||||
assert_eq(_mp(m, hs[index]).team, index / 2)
|
||||
|
||||
|
||||
func test_match_keeps_a_downed_team_alive_and_places_the_pair_together() -> void:
|
||||
var m: Match = _duos_match()
|
||||
var hs: Array[int] = m.participants.duplicate()
|
||||
_mp(m, hs[0]).health = 0
|
||||
_mp(m, hs[0]).last_attacker = m.entity_of[hs[2]]
|
||||
_mp(m, hs[0]).last_cause = SimEntity.CAUSE_WEAPON
|
||||
m.step()
|
||||
assert_true(_mp(m, hs[0]).downed)
|
||||
assert_eq(_place_of(m, hs[0]), 0, "down isn't placed")
|
||||
assert_true(m.alive().has(hs[0]), "still in the match")
|
||||
var downs: Array[Dictionary] = []
|
||||
for event: Dictionary in m.events:
|
||||
if event["type"] == "downed":
|
||||
downs.append(event)
|
||||
assert_eq(downs.size(), 1)
|
||||
assert_eq(downs[0]["by"], hs[2])
|
||||
assert_true(bool(m.kill_feed[-1].get("downed", false)), "the down is in the feed")
|
||||
assert_eq(m.stats[hs[2]]["eliminations"], 0, "a down isn't an elimination yet")
|
||||
# The teammate falls: both are out, sharing the place below the two teams left.
|
||||
_mp(m, hs[1]).health = 0
|
||||
_mp(m, hs[1]).last_attacker = m.entity_of[hs[4]]
|
||||
_mp(m, hs[1]).last_cause = SimEntity.CAUSE_WEAPON
|
||||
m.step()
|
||||
assert_eq(_place_of(m, hs[0]), 5)
|
||||
assert_eq(_place_of(m, hs[1]), 5)
|
||||
assert_eq(m.stats[hs[2]]["eliminations"], 1, "credited to who downed them")
|
||||
assert_eq(m.stats[hs[4]]["eliminations"], 1)
|
||||
assert_eq(m.phase, Match.PLAY)
|
||||
# One of the next team goes down, then the other: the last team wins, both of them.
|
||||
_mp(m, hs[2]).health = 0
|
||||
m.step()
|
||||
assert_true(_mp(m, hs[2]).downed)
|
||||
assert_eq(m.phase, Match.PLAY, "a downed player keeps the team in it")
|
||||
_mp(m, hs[3]).health = 0
|
||||
m.step()
|
||||
assert_eq(m.phase, Match.RESULTS)
|
||||
assert_eq(m.winners, [hs[4], hs[5]] as Array[int])
|
||||
assert_eq(_place_of(m, hs[2]), 3)
|
||||
assert_eq(_place_of(m, hs[3]), 3)
|
||||
|
||||
|
||||
func test_match_tie_break_prefers_a_standing_team_over_a_downed_one() -> void:
|
||||
var m: Match = _duos_match()
|
||||
var hs: Array[int] = m.participants.duplicate()
|
||||
# Teams 0 and 1 left, team 2 out.
|
||||
_mp(m, hs[4]).health = 0
|
||||
_mp(m, hs[5]).health = 0
|
||||
m.step()
|
||||
_mp(m, hs[0]).health = 0
|
||||
m.step()
|
||||
assert_true(_mp(m, hs[0]).downed)
|
||||
_mp(m, hs[1]).health = 1
|
||||
_mp(m, hs[2]).health = 1
|
||||
_mp(m, hs[3]).health = 1
|
||||
assert_eq(m._tie_break([hs[0], hs[2]] as Array[int]), hs[2], "standing beats downed, despite more health")
|
||||
@@ -0,0 +1 @@
|
||||
uid://b2cresp6auksd
|
||||
@@ -48,8 +48,9 @@ func _saw(m: Match, type: String) -> bool:
|
||||
## The state a fresh simulation for match `index` should have just after it starts.
|
||||
func _reference_hash(m: Match, index: int, players: int) -> String:
|
||||
var sim: Simulation = Simulation.new(m.match_seed(index))
|
||||
for _index: int in players:
|
||||
sim.add_player()
|
||||
for player_index: int in players:
|
||||
# Solo: everyone on a team of their own, as Match sets them.
|
||||
sim.set_team(sim.add_player(), player_index)
|
||||
sim.start_drop()
|
||||
sim.start_tide()
|
||||
sim.place_loot()
|
||||
|
||||
@@ -278,6 +278,11 @@ func test_teammates_spectate_their_living_team() -> void:
|
||||
var hs: Array[int] = m.participants.duplicate()
|
||||
_eliminate(m, hs[0])
|
||||
m.step()
|
||||
assert_true(_player(m, hs[0]).downed, "duos: down first (M7)")
|
||||
assert_eq(m.spectate_target(hs[0]), 0, "a downed player isn't spectating")
|
||||
_eliminate(m, hs[0])
|
||||
m.step()
|
||||
assert_true(_player(m, hs[0]).eliminated, "finished off")
|
||||
assert_eq(m.spectate_target(hs[0]), hs[1], "with no eliminator, the teammate")
|
||||
|
||||
|
||||
|
||||
@@ -140,13 +140,17 @@ func test_settings_controls_change_and_save_the_settings() -> void:
|
||||
|
||||
func test_practice_and_join_say_what_was_asked() -> void:
|
||||
var asked: Array = []
|
||||
menus.practice_requested.connect(func(bots: int, difficulty: int) -> void: asked.append(["practice", bots, difficulty]))
|
||||
menus.practice_requested.connect(func(bots: int, difficulty: int, team_size: int) -> void: asked.append(["practice", bots, difficulty, team_size]))
|
||||
menus.join_requested.connect(func(host: String, port: int, player_name: String) -> void: asked.append(["join", host, port, player_name]))
|
||||
menus.show_screen("practice", false)
|
||||
menus._bots.value = 5
|
||||
menus._difficulty.select(1)
|
||||
_press("practice", "Set out")
|
||||
assert_eq(asked.pop_back(), ["practice", 5, 0])
|
||||
assert_eq(asked.pop_back(), ["practice", 5, 0, 1])
|
||||
menus._mode.select(1)
|
||||
_press("practice", "Set out")
|
||||
assert_eq(asked.pop_back(), ["practice", 5, 0, Tuning.DUO_TEAM_SIZE], "duos (M7)")
|
||||
assert_eq(menus.settings.practice_team_size, Tuning.DUO_TEAM_SIZE)
|
||||
menus.show_screen("join", false)
|
||||
menus._name.text = "Wren"
|
||||
menus._address.text = "not a port:x"
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
## Plays bot-only duos matches (M7) on a run of seeds: 12 teams of two bots. Checks
|
||||
## every match ends with one winning team, bots went down and revived teammates, no hit
|
||||
## between teammates did damage, and the ticks kept within budget.
|
||||
##
|
||||
## tools/godot.sh --script res://tools/duo_matches.gd -- [--seeds=10] [--first=1]
|
||||
##
|
||||
## Prints one JSON line per match and a summary. Exits 1 if a check fails.
|
||||
extends SceneTree
|
||||
|
||||
|
||||
func _init() -> void:
|
||||
var count: int = 10
|
||||
var first: int = 1
|
||||
for arg: String in OS.get_cmdline_user_args():
|
||||
if arg.begins_with("--seeds="):
|
||||
count = arg.trim_prefix("--seeds=").to_int()
|
||||
elif arg.begins_with("--first="):
|
||||
first = arg.trim_prefix("--first=").to_int()
|
||||
var results: Array[Dictionary] = []
|
||||
var downs: int = 0
|
||||
var revives: int = 0
|
||||
var team_hits: int = 0
|
||||
var one_team: int = 0
|
||||
for seed_value: int in range(first, first + count):
|
||||
var result: Dictionary = BotBatch.run_match(seed_value, Tuning.SOLO_PLAYERS, -1, false, Tuning.DUO_TEAM_SIZE)
|
||||
result.erase("building")
|
||||
results.append(result)
|
||||
downs += int(result["downs"])
|
||||
revives += int(result["revives"])
|
||||
team_hits += int(result["team_hits"])
|
||||
one_team += 1 if int(result["winner_teams"]) == 1 else 0
|
||||
print(JSON.stringify({"seed": seed_value, "finished": result["finished"], "ticks": result["ticks"],
|
||||
"winner_teams": result["winner_teams"], "downs": result["downs"], "revives": result["revives"],
|
||||
"team_hits": result["team_hits"], "causes": result["causes"], "p99_us": result["timing"].get("p99_us", 0)}))
|
||||
var total: Dictionary = BotBatch.summarise(results)
|
||||
var problems: Array[String] = []
|
||||
if total["finished"] != count or one_team != count:
|
||||
problems.append("%d of %d matches finished with one winning team" % [one_team, count])
|
||||
if downs == 0 or revives == 0:
|
||||
problems.append("bots went down %d times and revived %d times; both should happen" % [downs, revives])
|
||||
if team_hits > 0:
|
||||
problems.append("%d hits between teammates did damage" % team_hits)
|
||||
if int(total["worst_p99_us"]) > ServerLoop.TICK_BUDGET_USEC:
|
||||
problems.append("the worst match's p99 tick was %d us, over the %d us budget" % [total["worst_p99_us"], ServerLoop.TICK_BUDGET_USEC])
|
||||
for problem: String in problems:
|
||||
print("duo-matches FAIL: %s" % problem)
|
||||
if problems.is_empty():
|
||||
print("duo-matches: ok (%d matches, each won by one team, %d downs, %d revives, %.1f%% drowned, worst p99 %d us)" % [count, downs, revives, total["drown_share"] * 100.0, total["worst_p99_us"]])
|
||||
quit(0 if problems.is_empty() else 1)
|
||||
@@ -0,0 +1 @@
|
||||
uid://ddv3is8k7bg05
|
||||
Executable
+19
@@ -0,0 +1,19 @@
|
||||
#!/usr/bin/env bash
|
||||
# Plays bot-only duos matches on a run of seeds, under nice, and prints one JSON line per
|
||||
# match, a summary and the verdict. See tools/duo_matches.gd for what is checked.
|
||||
#
|
||||
# tools/duo_matches.sh seeds 1 to 10
|
||||
# DUO_MATCH_SEEDS=5 DUO_MATCH_FIRST=40 tools/duo_matches.sh
|
||||
set -uo pipefail
|
||||
cd "$(dirname "${BASH_SOURCE[0]}")/.."
|
||||
|
||||
count="${DUO_MATCH_SEEDS:-10}"
|
||||
first="${DUO_MATCH_FIRST:-1}"
|
||||
raw="$(nice -n 15 tools/godot.sh --script res://tools/duo_matches.gd -- --seeds="$count" --first="$first" 2>&1)"
|
||||
code=$?
|
||||
grep -E '^\{|^duo-matches' <<<"$raw"
|
||||
if [[ "$code" -ne 0 ]] && ! grep -q '^duo-matches' <<<"$raw"; then
|
||||
echo "duo-matches FAIL: the run exited $code"
|
||||
tail -n 15 <<<"$raw"
|
||||
fi
|
||||
exit "$code"
|
||||
Reference in New Issue
Block a user