|
|
|
@@ -0,0 +1,231 @@
|
|
|
|
|
extends TestCase
|
|
|
|
|
|
|
|
|
|
## Water and swimming from issue W6: wading, swimming, stamina, breath, drowning, and a
|
|
|
|
|
## sea level that can change mid-match.
|
|
|
|
|
|
|
|
|
|
const EAST: float = PI * 0.5
|
|
|
|
|
const WEST: float = -PI * 0.5
|
|
|
|
|
const SECOND: int = Tuning.TICK_RATE_HZ
|
|
|
|
|
|
|
|
|
|
var _tick: int = 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func before_each() -> void:
|
|
|
|
|
_tick = 0
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
## Flat ground at height 0 for x < 20, sloping down at 1 in 4 to -10 at x = 60, flat beyond.
|
|
|
|
|
func _beach() -> SimGround:
|
|
|
|
|
var side: int = 128
|
|
|
|
|
var values: PackedFloat32Array = PackedFloat32Array()
|
|
|
|
|
values.resize(side * side)
|
|
|
|
|
for z: int in side:
|
|
|
|
|
for x: int in side:
|
|
|
|
|
values[z * side + x] = -clampf((float(x) - 20.0) * 0.25, 0.0, 10.0)
|
|
|
|
|
return SimGround.from_heights(values, side, 1.0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func _player(at: Vector3) -> SimEntity:
|
|
|
|
|
var player: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
|
|
|
|
|
player.position = at
|
|
|
|
|
player.health = Tuning.PLAYER_MAX_HEALTH
|
|
|
|
|
player.on_ground = true
|
|
|
|
|
Water.reset(player)
|
|
|
|
|
return player
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func _run(player: SimEntity, ground: SimGround, sea: float, ticks: int, move: Vector2, yaw: float, buttons: int = 0, drown_dps: int = 5) -> void:
|
|
|
|
|
for _index: int in ticks:
|
|
|
|
|
var command: PlayerCommand = PlayerCommand.from_input(_tick, move, yaw, 0.0, buttons)
|
|
|
|
|
_tick += 1
|
|
|
|
|
Movement.step(player, command, ground, sea)
|
|
|
|
|
Water.update(player, sea, drown_dps, command.is_pressed(PlayerCommand.BUTTON_SPRINT))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_wading_slows_walkers_and_stops_sprinting() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
# Sea 0.8 m over the flat part of the beach: deeper than WADE_DEPTH, too shallow to swim.
|
|
|
|
|
var player: SimEntity = _player(Vector3(5.0, 0.0, 64.0))
|
|
|
|
|
_run(player, ground, 0.8, SECOND, Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_SPRINT)
|
|
|
|
|
assert_false(player.swimming)
|
|
|
|
|
assert_true(player.on_ground)
|
|
|
|
|
assert_near(player.position.x - 5.0, Tuning.WADE_SPEED, 0.01)
|
|
|
|
|
# Ankle-deep water doesn't slow anyone.
|
|
|
|
|
var dry: SimEntity = _player(Vector3(5.0, 0.0, 70.0))
|
|
|
|
|
_run(dry, ground, Tuning.WADE_DEPTH - 0.1, SECOND, Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_SPRINT)
|
|
|
|
|
assert_near(dry.position.x - 5.0, Tuning.SPRINT_SPEED, 0.01)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_walking_into_the_sea_swims_and_walking_out_stands_again() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
var player: SimEntity = _player(Vector3(10.0, 0.0, 64.0))
|
|
|
|
|
_run(player, ground, -2.0, SECOND, Vector2(0.0, 1.0), EAST)
|
|
|
|
|
assert_near(player.position.x, 10.0 + Tuning.WALK_SPEED, 0.01)
|
|
|
|
|
var reached_swim: bool = false
|
|
|
|
|
for _tick: int in SECOND * 15:
|
|
|
|
|
_run(player, ground, -2.0, 1, Vector2(0.0, 1.0), EAST)
|
|
|
|
|
if player.swimming:
|
|
|
|
|
reached_swim = true
|
|
|
|
|
break
|
|
|
|
|
# The floor drops 1 in 4, so swimming starts where it is SWIM_DEPTH under the sea.
|
|
|
|
|
var expected_x: float = 20.0 + (2.0 + Tuning.SWIM_DEPTH) * 4.0
|
|
|
|
|
assert_near(player.position.x, expected_x, 0.3)
|
|
|
|
|
assert_true(reached_swim, "never started swimming, at %s" % player.position)
|
|
|
|
|
assert_false(player.on_ground)
|
|
|
|
|
# Floating: feet SWIM_FLOAT_DEPTH under the surface, head out.
|
|
|
|
|
_run(player, ground, -2.0, SECOND * 2, Vector2(0.0, 1.0), EAST)
|
|
|
|
|
assert_near(player.position.y, -2.0 - Tuning.SWIM_FLOAT_DEPTH, 0.05)
|
|
|
|
|
assert_false(Water.head_under(player, -2.0))
|
|
|
|
|
var x0: float = player.position.x
|
|
|
|
|
_run(player, ground, -2.0, SECOND, Vector2(0.0, 1.0), EAST)
|
|
|
|
|
assert_near(player.position.x - x0, Tuning.SWIM_SPEED, 0.05)
|
|
|
|
|
# Back to shore: standing again once the water is shallow.
|
|
|
|
|
_run(player, ground, -2.0, SECOND * 15, Vector2(0.0, 1.0), WEST)
|
|
|
|
|
assert_false(player.swimming, "still swimming at %s" % player.position)
|
|
|
|
|
assert_true(player.on_ground)
|
|
|
|
|
assert_true(player.position.x < 20.0)
|
|
|
|
|
assert_near(player.position.y, ground.terrain_height(player.position.x, 64.0), 0.01)
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_swimming_drains_stamina_and_exhaustion_drowns() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
var sea: float = 0.0
|
|
|
|
|
var player: SimEntity = _player(Vector3(100.0, -10.0, 64.0))
|
|
|
|
|
_run(player, ground, sea, 2, Vector2.ZERO, EAST)
|
|
|
|
|
assert_true(player.swimming)
|
|
|
|
|
var full: int = Water.max_stamina_ticks()
|
|
|
|
|
# Sprint-swimming costs more than paddling.
|
|
|
|
|
_run(player, ground, sea, SECOND, Vector2(0.0, 1.0), WEST, PlayerCommand.BUTTON_SPRINT)
|
|
|
|
|
var after_sprint: int = player.stamina_ticks
|
|
|
|
|
assert_eq(full - after_sprint, (SECOND + 2) * Tuning.SWIM_SPRINT_STAMINA_COST - 2 * (Tuning.SWIM_SPRINT_STAMINA_COST - 1))
|
|
|
|
|
_run(player, ground, sea, SECOND, Vector2(0.0, 1.0), EAST)
|
|
|
|
|
assert_eq(after_sprint - player.stamina_ticks, SECOND)
|
|
|
|
|
# Tread water until exhausted: then the swimmer slips under and loses breath.
|
|
|
|
|
_run(player, ground, sea, player.stamina_ticks, Vector2.ZERO, EAST)
|
|
|
|
|
assert_eq(player.stamina_ticks, 0)
|
|
|
|
|
_run(player, ground, sea, SECOND * 2, Vector2.ZERO, EAST)
|
|
|
|
|
assert_true(Water.head_under(player, sea), "an exhausted swimmer should go under, feet at %.2f" % player.position.y)
|
|
|
|
|
assert_true(player.breath_ticks < Water.max_breath_ticks())
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH, "no damage while breath lasts")
|
|
|
|
|
# Breath runs out, then drown damage lands once a second.
|
|
|
|
|
_run(player, ground, sea, player.breath_ticks, Vector2.ZERO, EAST)
|
|
|
|
|
assert_eq(player.breath_ticks, 0)
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH)
|
|
|
|
|
_run(player, ground, sea, SECOND * 3, Vector2.ZERO, EAST, 0, 7)
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH - 21)
|
|
|
|
|
# Drowning continues to death and stops there.
|
|
|
|
|
_run(player, ground, sea, SECOND * 30, Vector2.ZERO, EAST, 0, 7)
|
|
|
|
|
assert_eq(player.health, 0)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_diving_costs_breath_and_surfacing_restores_it() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
var player: SimEntity = _player(Vector3(100.0, -10.0, 64.0))
|
|
|
|
|
# Rise from the sea floor to the surface first.
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 8, Vector2.ZERO, EAST)
|
|
|
|
|
assert_eq(player.breath_ticks, Water.max_breath_ticks())
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 2, Vector2.ZERO, EAST, PlayerCommand.BUTTON_CROUCH)
|
|
|
|
|
assert_true(Water.head_under(player, 0.0), "diving should take the head under")
|
|
|
|
|
assert_true(player.position.y < -Tuning.SWIM_FLOAT_DEPTH - 1.0)
|
|
|
|
|
var low: int = player.breath_ticks
|
|
|
|
|
assert_true(low < Water.max_breath_ticks())
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 3, Vector2.ZERO, EAST)
|
|
|
|
|
assert_false(Water.head_under(player, 0.0))
|
|
|
|
|
assert_true(player.breath_ticks > low)
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 10, Vector2.ZERO, EAST)
|
|
|
|
|
assert_eq(player.breath_ticks, Water.max_breath_ticks())
|
|
|
|
|
# Divers rest on the sea floor rather than sinking through it.
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 10, Vector2.ZERO, EAST, PlayerCommand.BUTTON_CROUCH)
|
|
|
|
|
assert_true(player.position.y >= ground.terrain_height(100.0, 64.0) - 0.001)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_falling_into_deep_water_does_no_fall_damage() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
var player: SimEntity = _player(Vector3(100.0, 40.0, 64.0))
|
|
|
|
|
player.on_ground = false
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 4, Vector2.ZERO, EAST)
|
|
|
|
|
assert_true(player.swimming)
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH)
|
|
|
|
|
# The same fall onto dry ground hurts.
|
|
|
|
|
var dry: SimEntity = _player(Vector3(5.0, 40.0, 64.0))
|
|
|
|
|
dry.on_ground = false
|
|
|
|
|
_run(dry, ground, 0.0, SECOND * 4, Vector2.ZERO, EAST)
|
|
|
|
|
assert_true(dry.health < Tuning.PLAYER_MAX_HEALTH)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_jumping_from_the_water_leaves_it_and_lands_back_in() -> void:
|
|
|
|
|
var ground: SimGround = _beach()
|
|
|
|
|
var player: SimEntity = _player(Vector3(100.0, -10.0, 64.0))
|
|
|
|
|
_run(player, ground, 0.0, SECOND * 8, Vector2.ZERO, EAST)
|
|
|
|
|
var float_y: float = player.position.y
|
|
|
|
|
_run(player, ground, 0.0, 1, Vector2.ZERO, EAST, PlayerCommand.BUTTON_JUMP)
|
|
|
|
|
assert_false(player.swimming)
|
|
|
|
|
var peak: float = player.position.y
|
|
|
|
|
for _i: int in SECOND:
|
|
|
|
|
_run(player, ground, 0.0, 1, Vector2.ZERO, EAST)
|
|
|
|
|
peak = maxf(peak, player.position.y)
|
|
|
|
|
assert_true(peak > float_y + 1.0, "jumped only to %.2f from %.2f" % [peak, float_y])
|
|
|
|
|
_run(player, ground, 0.0, SECOND, Vector2.ZERO, EAST)
|
|
|
|
|
assert_true(player.swimming)
|
|
|
|
|
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH)
|
|
|
|
|
# No jumping out with no stamina left.
|
|
|
|
|
player.stamina_ticks = 0
|
|
|
|
|
_run(player, ground, 0.0, 1, Vector2.ZERO, EAST, PlayerCommand.BUTTON_JUMP)
|
|
|
|
|
assert_true(player.swimming)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_raising_the_sea_takes_effect_on_the_next_tick() -> void:
|
|
|
|
|
var sim: Simulation = Simulation.new(1, _beach())
|
|
|
|
|
var id: int = sim.add_player()
|
|
|
|
|
var player: SimEntity = sim.entities.find(id)
|
|
|
|
|
player.position = Vector3(10.0, 0.0, 64.0)
|
|
|
|
|
player.on_ground = true
|
|
|
|
|
assert_eq(sim.sea_level, Tuning.SEA_LEVEL_START)
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_false(player.swimming)
|
|
|
|
|
sim.set_sea_level(3.0)
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_true(player.swimming, "the sea rose over the player's head but they aren't swimming")
|
|
|
|
|
for _i: int in SECOND * 3:
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_near(player.position.y, 3.0 - Tuning.SWIM_FLOAT_DEPTH, 0.05)
|
|
|
|
|
assert_eq(player.breath_ticks, Water.max_breath_ticks(), "a swimmer floating at the surface breathes again")
|
|
|
|
|
# Wading depth slows walking at once.
|
|
|
|
|
sim.set_sea_level(0.9)
|
|
|
|
|
for _i: int in SECOND * 2:
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_false(player.swimming)
|
|
|
|
|
assert_true(player.on_ground)
|
|
|
|
|
var x0: float = player.position.x
|
|
|
|
|
for _i: int in SECOND:
|
|
|
|
|
sim.submit_command(id, PlayerCommand.from_input(sim.tick, Vector2(0.0, 1.0), WEST, 0.0, PlayerCommand.BUTTON_SPRINT))
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_near(x0 - player.position.x, Tuning.WADE_SPEED, 0.05)
|
|
|
|
|
# Dropping the sea leaves a dry player walking at full pace.
|
|
|
|
|
sim.set_sea_level(-5.0)
|
|
|
|
|
x0 = player.position.x
|
|
|
|
|
for _i: int in SECOND:
|
|
|
|
|
sim.submit_command(id, PlayerCommand.from_input(sim.tick, Vector2(0.0, 1.0), WEST, 0.0, 0))
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_near(x0 - player.position.x, Tuning.WALK_SPEED, 0.05)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func test_water_state_is_hashed_and_deterministic() -> void:
|
|
|
|
|
var a: Simulation = Simulation.new(2, _beach())
|
|
|
|
|
var b: Simulation = Simulation.new(2, _beach())
|
|
|
|
|
var a_id: int = 0
|
|
|
|
|
for sim: Simulation in [a, b]:
|
|
|
|
|
var id: int = sim.add_player()
|
|
|
|
|
a_id = id
|
|
|
|
|
var player: SimEntity = sim.entities.find(id)
|
|
|
|
|
player.position = Vector3(100.0, -10.0, 64.0)
|
|
|
|
|
for _i: int in SECOND * 3:
|
|
|
|
|
sim.submit_command(id, PlayerCommand.from_input(sim.tick, Vector2(0.0, 1.0), EAST, 0.0, PlayerCommand.BUTTON_CROUCH))
|
|
|
|
|
sim.step()
|
|
|
|
|
assert_eq(a.state_hash(), b.state_hash())
|
|
|
|
|
(a.entities.find(a_id) as SimEntity).breath_ticks -= 1
|
|
|
|
|
assert_ne(a.state_hash(), b.state_hash(), "breath must be part of the hash")
|
|
|
|
|
(a.entities.find(a_id) as SimEntity).breath_ticks += 1
|
|
|
|
|
a.set_sea_level(0.001)
|
|
|
|
|
assert_ne(a.state_hash(), b.state_hash(), "the sea level must be part of the hash")
|