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

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

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

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

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

Closes #30

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

267 lines
12 KiB
GDScript

## Thrown charges (B8): the powder keg, and any weapon with a `blast_radius`.
##
## Fire with a charge held throws one from the stack, along the look direction lifted by
## Tuning.THROW_LIFT, at the weapon's projectile_speed. The charge is a projectile
## entity that flies under projectile_gravity. When it strikes something it loses its
## sideways speed and drops; when it lands it rests (`on_ground`), and if what it rests
## on goes, it falls again. Its fuse, in `use_ticks`, runs from the throw, and when it
## runs out the charge blows wherever it is. It never vanishes unexploded, except below
## the world.
##
## A blast reaches everything within `blast_radius` of its middle, measured to the
## nearest point of a player's body, a piece or a prop:
## - Line of sight: terrain, pieces, props and fixed solids in the way shield what is
## behind them. Players don't. A player counts as seen if the middle of their body or
## their head is in sight.
## - 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, 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,
## so what it destroys can't change what else it reaches.
class_name Explosives
extends RefCounted
## How high above where it lies a charge's blast is measured from.
const BLAST_LIFT: float = 0.3
## A thrown charge stops this far short of what it hits.
const STANDOFF: float = 0.05
## Below this sideways speed, a charge that hits something has landed.
const LANDED_SPEED: float = 0.01
## Throws one charge from the held stack if the player is ready. Returns true if one was
## thrown. Called by Simulation for fire with a thrown weapon held.
static func throw(sim: Simulation, player: SimEntity) -> bool:
var def: ItemDef = Inventory.held_def(player)
if def == null or not def.thrown or player.action_cooldown > 0:
return false
var slot: int = Inventory.held_slot(player)
if player.slot_counts[slot] <= 0:
return false
var tier: int = player.slot_tiers[slot]
Inventory.take_from_slot(player, slot, 1)
player.action_cooldown = def.fire_interval_ticks()
var from: Vector3 = Harvest.eye(player)
var look: Vector3 = Harvest.look_direction(player)
var direction: Vector3 = (look + Vector3(0.0, Tuning.THROW_LIFT, 0.0)).normalized()
var charge: SimEntity = sim.entities.create(SimEntity.ARCHETYPE_PROJECTILE)
charge.position = from
charge.origin = from
charge.velocity = direction * def.projectile_speed
charge.owner_id = player.id
charge.item = def.code
charge.item_tier = tier
charge.use_ticks = fuse_ticks(def)
sim.projectiles.append(charge.id)
sim.events.append({"type": "shot", "player": player.id, "item": def.code, "from": from, "direction": direction})
return true
## The fuse in ticks, at least one.
static func fuse_ticks(def: ItemDef) -> int:
return maxi(roundi(def.fuse_seconds * Tuning.TICK_RATE_HZ), 1)
## True for a projectile that is a charge rather than a shot.
static func is_charge(def: ItemDef) -> bool:
return def != null and def.blast_radius > 0.0
## One tick of a charge: fly, drop or lie still, then count down the fuse. Returns false
## once the charge is gone. Called by Weapons.advance_projectiles().
static func advance(sim: Simulation, charge: SimEntity, def: ItemDef) -> bool:
var dt: float = Simulation.SECONDS_PER_TICK
if charge.on_ground and not _supported(sim, charge.position):
charge.on_ground = false
if not charge.on_ground:
charge.velocity.y -= def.projectile_gravity * dt
var to: Vector3 = charge.position + charge.velocity * dt
var hit: Weapons.Hit
if Vector2(charge.velocity.x, charge.velocity.z).length() <= LANDED_SPEED:
# Dropping straight down: only the ground and solids stop it, so it can't
# come to rest on someone's head.
hit = Weapons.Hit.new()
hit.fraction = sim.ground.raycast(charge.position, to)
hit.kind = Weapons.HIT_TERRAIN if hit.fraction < 1.0 else Weapons.HIT_NONE
hit.point = charge.position.lerp(to, hit.fraction)
else:
# Its thrower's own body doesn't stop it as it leaves their hand.
hit = Weapons.trace(sim, charge.position, to, charge.owner_id if charge.use_ticks > fuse_ticks(def) - 6 else 0)
if hit.kind == Weapons.HIT_NONE:
charge.position = to
else:
var travel: Vector3 = to - charge.position
var back: float = minf(STANDOFF, travel.length() * hit.fraction)
charge.position = hit.point - travel.normalized() * back
var sideways: float = Vector2(charge.velocity.x, charge.velocity.z).length()
if sideways <= LANDED_SPEED or charge.velocity.y <= 0.0 and _supported(sim, charge.position):
charge.velocity = Vector3.ZERO
charge.on_ground = true
else:
# Struck something side-on: drop down it.
charge.velocity = Vector3(0.0, minf(charge.velocity.y, 0.0), 0.0)
charge.use_ticks -= 1
if charge.use_ticks <= 0:
blast(sim, charge.owner_id, def, charge.item_tier, charge.position + Vector3(0.0, BLAST_LIFT, 0.0))
return false
return charge.position.y >= Tuning.BUILD_MIN_LEVEL * Tuning.BUILD_LEVEL_METRES - 10.0
## True if something is just under `point` to lie on.
static func _supported(sim: Simulation, point: Vector3) -> bool:
return sim.ground.raycast(point, point - Vector3(0.0, STANDOFF * 3.0, 0.0)) < 1.0
## Damage at `distance` from the middle of a blast of `full` reaching `radius`.
static func falloff(full: float, distance: float, radius: float) -> float:
if distance > radius:
return 0.0
var t: float = clampf(distance / radius, 0.0, 1.0) if radius > 0.0 else 0.0
return full * lerpf(1.0, Tuning.BLAST_EDGE_FACTOR, t)
## Blows a charge of `def` thrown by `thrower` at `center`. Returns how many players,
## pieces and props it damaged, for tests.
static func blast(sim: Simulation, thrower: int, def: ItemDef, tier: int, center: Vector3) -> int:
var radius: float = def.blast_radius
var scale: float = Weapons.tier_multiplier(tier)
sim.events.append({"type": "explosion", "player": thrower, "item": def.code, "point": center, "radius": radius})
# What the sound and effects hear as where it landed.
sim.events.append({"type": "impact", "player": thrower, "item": def.code, "point": center, "hit": Weapons.HIT_NONE, "target": -1})
var sight: Sight = Sight.new(sim, center, radius)
# Players.
var hurt: Array[Vector3i] = []
for entity: SimEntity in sim.entities.entities():
if entity.archetype != SimEntity.ARCHETYPE_PLAYER or entity.eliminated or entity.drop_state == Drop.ABOARD:
continue
var box: AABB = Weapons.body_box(entity)
var distance: float = _distance_to_box(box, center)
if distance > radius:
continue
var middle: Vector3 = box.get_center()
var head: Vector3 = Vector3(middle.x, box.end.y - Tuning.HEAD_HEIGHT * 0.5, middle.z)
if not (sight.clear(middle, -1, -1) or sight.clear(head, -1, -1)):
continue
var amount: float = falloff(def.damage * scale, distance, radius)
if entity.id == thrower:
amount *= Tuning.BLAST_SELF_FACTOR
hurt.append(Vector3i(entity.id, roundi(amount), 0))
# Pieces and props, each once, at their nearest solid in sight.
var pieces: Dictionary = {}
var props: Dictionary = {}
for index: int in sight.boxes.size():
var box: AABB = sight.boxes[index]
var distance: float = _distance_to_box(box, center)
if distance > radius:
continue
var piece: int = sight.pieces[index]
var prop: int = sight.props[index]
if piece == 0 and prop < 0:
continue
var table: Dictionary = pieces if piece != 0 else props
var key: int = piece if piece != 0 else prop
if distance >= float(table.get(key, INF)):
continue
var target: Vector3 = _closest_point(box, center).lerp(box.get_center(), 0.05)
if sight.touching[index] or sight.clear(target, piece, prop):
table[key] = distance
var count: int = 0
for entry: Vector3i in hurt:
if Weapons.damage_player(sim, sim.entities.find(entry.x), entry.y, thrower, false, def.code) > 0:
count += 1
var piece_ids: Array = pieces.keys()
piece_ids.sort()
for piece_id: int in piece_ids:
if sim.structures.find(piece_id) == null:
continue
sim.damage_piece(piece_id, roundi(falloff(def.structure_damage * scale, pieces[piece_id], radius)), "blast")
count += 1
var prop_ids: Array = props.keys()
prop_ids.sort()
for prop: int in prop_ids:
if not sim.props.is_standing(prop):
continue
if sim.damage_prop(prop, roundi(falloff(def.structure_damage * scale, props[prop], radius))):
sim.events.append({"type": "prop_destroyed", "prop": prop})
count += 1
return count
## What can block a blast: every solid near it once, with the piece or prop it belongs
## to, and the highest terrain under it.
class Sight:
extends RefCounted
## Terrain is checked along a ray this often, in metres. Coarser than a shot's trace:
## a blast only needs to know whether a ridge is in the way.
const TERRAIN_STEP: float = 0.5
## Points this close above the terrain still count as above it.
const TERRAIN_SLACK: float = 0.05
var ground: SimGround
var center: Vector3
var boxes: Array[AABB] = []
var pieces: PackedInt32Array = PackedInt32Array()
var props: PackedInt32Array = PackedInt32Array()
## True for a solid the middle of the blast is inside or touching. Those shield
## nothing.
var touching: Array[bool] = []
var highest_terrain: float = 0.0
func _init(sim: Simulation, at: Vector3, radius: float) -> void:
ground = sim.ground
center = at
var seen: Dictionary = {}
for solid_id: int in ground.solids_near(at.x - radius, at.z - radius, at.x + radius, at.z + radius):
if seen.has(solid_id):
continue
seen[solid_id] = true
var box: AABB = ground.solids[solid_id]
if box.size == Vector3.ZERO or _gap(box, at) > radius:
continue
boxes.append(box)
pieces.append(sim.structures.piece_of_solid(solid_id))
props.append(sim.props.prop_of_solid(solid_id))
touching.append(box.grow(0.01).has_point(at))
highest_terrain = ground.max_height_in(at.x - radius, at.z - radius, at.x + radius, at.z + radius)
## True if nothing lies between the middle and `to` except solids of `piece` or `prop`
## (-1 for none) and solids the middle touches.
func clear(to: Vector3, piece: int, prop: int) -> bool:
var low: Vector3 = center.min(to)
var high: Vector3 = center.max(to)
for index: int in boxes.size():
if touching[index] or (piece > 0 and pieces[index] == piece) or (prop >= 0 and props[index] == prop):
continue
var box: AABB = boxes[index]
if box.end.x < low.x or box.position.x > high.x or box.end.y < low.y or box.position.y > high.y or box.end.z < low.z or box.position.z > high.z:
continue
if ground.ray_box(center, to, box) < 0.999:
return false
return _terrain_clear(to)
func _terrain_clear(to: Vector3) -> bool:
if minf(center.y, to.y) >= highest_terrain:
return true
var length: float = center.distance_to(to)
var steps: int = maxi(ceili(length / TERRAIN_STEP), 1)
for step: int in range(1, steps):
var point: Vector3 = center.lerp(to, float(step) / steps)
if point.y < ground.terrain_height(point.x, point.z) - TERRAIN_SLACK:
return false
return true
static func _gap(box: AABB, point: Vector3) -> float:
return point.distance_to(point.clamp(box.position, box.end))
static func _closest_point(box: AABB, point: Vector3) -> Vector3:
return point.clamp(box.position, box.end)
static func _distance_to_box(box: AABB, point: Vector3) -> float:
return point.distance_to(_closest_point(box, point))