W1: Third-person character controller and camera

Simulation (src/sim/):
- SimGround holds the terrain heightfield (bilinear heights, normals)
  and axis-aligned box solids, with support, body-overlap, point and
  ray queries. The island generator and building will fill it.
- Movement steps a player per tick: walk, sprint (forward only),
  crouch (lower body, slower, no jump), jump with exact constant-gravity
  integration, air control, step-up onto ledges up to STEP_HEIGHT,
  ground snapping on downhill walks, slopes over MAX_SLOPE_DEGREES that
  block walking and jumping uphill and make players slide (speed capped),
  ceiling bumps, sliding along walls, and fall damage from impact speed.
- Gravity now applies on ticks with no command. on_ground and crouching
  are part of the state hash. New movement numbers are in Tuning.
- Fixed the strafe direction: right is forward x up in Godot's frame,
  (-cos yaw, 0, sin yaw). Documented the look convention.

Client (src/client/):
- CameraRig places an over-the-shoulder camera with an eased
  aim-down-sights blend (closer, narrower FOV), casting against the same
  SimGround: pivot to shoulder, shoulder back, then a straight line from
  the pivot, with a final clearance pull-in so the near plane never
  enters geometry.
- InputSettings: mouse sensitivity, aim sensitivity scale and invert-Y,
  clamped and saved to user://settings.cfg. PlayerCamera applies both.

Tests: 46 new across movement, ground queries, camera and settings,
including a 24,480-view scripted camera sweep through five arenas (wall,
corridor, low roof, corner, steep bank) that checks the eye and every
near-plane corner stay out of geometry with a clear line to the pivot.
The hash test now flips a high stick bit, because a 1/127 nudge to an
airborne player moves them less than the hash's millimetre.
Capture scenarios camera, camera_wall and camera_aim.

Closes #8

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
2026-11-09 20:24:02 -05:00
co-authored by Claude Opus 5.5
parent 68635d5fba
commit 70e88cec8a
29 changed files with 1213 additions and 23 deletions
+6
View File
@@ -0,0 +1,6 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/camera_scene.gd" id="1"]
[node name="CaptureCamera" type="Node3D"]
script = ExtResource("1")
+8
View File
@@ -0,0 +1,8 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/camera_scene.gd" id="1"]
[node name="CaptureCameraAim" type="Node3D"]
script = ExtResource("1")
yaw_degrees = 20.0
aiming = true
+26
View File
@@ -0,0 +1,26 @@
## Capture scenario for the third-person camera: the shore scene with a stand-in player,
## viewed through PlayerCamera and CameraRig as in the game.
extends "res://test/capture/smoke_scene.gd"
@export var feet: Vector3 = Vector3(1.0, 0.0, 0.5)
@export var yaw_degrees: float = 0.0
@export var pitch_degrees: float = -8.0
@export var aiming: bool = false
func _add_camera() -> void:
var body: CapsuleMesh = CapsuleMesh.new()
body.radius = Tuning.PLAYER_RADIUS
body.height = Tuning.PLAYER_HEIGHT
_place(body, feet + Vector3.UP * Tuning.PLAYER_HEIGHT * 0.5, Color(0.2, 0.42, 0.36))
var camera: PlayerCamera = PlayerCamera.new()
camera.ground = ground
camera.target_feet = feet
camera.yaw = deg_to_rad(yaw_degrees)
camera.pitch = deg_to_rad(pitch_degrees)
camera.aiming = aiming
if aiming:
camera.rig.aim_blend = 1.0
add_child(camera)
camera.make_current()
camera.snap()
+1
View File
@@ -0,0 +1 @@
uid://cxokowai701cm
+9
View File
@@ -0,0 +1,9 @@
[gd_scene load_steps=2 format=3]
[ext_resource type="Script" path="res://test/capture/camera_scene.gd" id="1"]
[node name="CaptureCameraWall" type="Node3D"]
script = ExtResource("1")
feet = Vector3(-1.5, 0, 2.4)
yaw_degrees = 180.0
pitch_degrees = -5.0
+11
View File
@@ -2,6 +2,9 @@
## post, under a procedural sky. Everything is built in code, so there are no assets.
extends Node3D
## The solid shape of the scene, for scenarios that need collision (the camera rig).
var ground: SimGround = SimGround.flat(0.0)
func _ready() -> void:
var environment: Environment = Environment.new()
@@ -35,6 +38,11 @@ func _ready() -> void:
_cylinder(0.35, 5.0, Vector3(5.0, 2.5, -2.0), Color(0.55, 0.36, 0.22))
_cylinder(0.6, 0.8, Vector3(5.0, 5.4, -2.0), Color(0.72, 0.22, 0.18))
_add_camera()
## Override to view the scene differently.
func _add_camera() -> void:
var camera: Camera3D = Camera3D.new()
camera.position = Vector3(-6.0, 6.0, -16.0)
add_child(camera)
@@ -46,9 +54,12 @@ func _box(size: Vector3, at: Vector3, colour: Color) -> void:
var mesh: BoxMesh = BoxMesh.new()
mesh.size = size
_place(mesh, at, colour)
if at.y + size.y * 0.5 > 0.0:
ground.add_solid(AABB(at - size * 0.5, size))
func _cylinder(radius: float, height: float, at: Vector3, colour: Color) -> void:
ground.add_solid(AABB(at - Vector3(radius, height * 0.5, radius), Vector3(radius * 2.0, height, radius * 2.0)))
var mesh: CylinderMesh = CylinderMesh.new()
mesh.top_radius = radius
mesh.bottom_radius = radius
+134
View File
@@ -0,0 +1,134 @@
extends TestCase
const ASPECT: float = 16.0 / 9.0
func test_open_ground_places_camera_behind_and_right() -> void:
var rig: CameraRig = CameraRig.new()
var feet: Vector3 = Vector3(100.0, 0.0, 100.0)
var view: Transform3D = rig.solve(feet, 0.0, 0.0, false, SimGround.flat())
var pivot: Vector3 = CameraRig.pivot(feet, false)
# Yaw 0 faces +z, so the camera sits on -z, and screen-right is -x.
var expected: Vector3 = pivot + Vector3(-CameraRig.SHOULDER, 0.0, -CameraRig.DISTANCE)
assert_true(view.origin.distance_to(expected) < 0.001, "camera at %s" % view.origin)
assert_true((-view.basis.z).distance_to(Vector3(0.0, 0.0, 1.0)) < 0.001, "camera must look along +z")
func test_strafing_right_moves_towards_screen_right() -> void:
for yaw: float in [0.0, 1.0, 2.5, 4.0, 5.5]:
var view: Transform3D = CameraRig.new().solve(Vector3(500.0, 0.0, 500.0), yaw, 0.0, false, SimGround.flat())
var player: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
player.position = Vector3(500.0, 0.0, 500.0)
player.on_ground = true
Movement.step(player, PlayerCommand.from_input(0, Vector2(1.0, 0.0), yaw, 0.0), SimGround.flat())
var moved: Vector3 = (player.position - Vector3(500.0, 0.0, 500.0)).normalized()
assert_true(moved.dot(view.basis.x) > 0.99, "yaw %f: strafe right went %s" % [yaw, moved])
# And walking forward goes where the camera looks.
var walker: SimEntity = SimEntity.new(2, SimEntity.ARCHETYPE_PLAYER)
walker.position = Vector3(500.0, 0.0, 500.0)
walker.on_ground = true
Movement.step(walker, PlayerCommand.from_input(0, Vector2(0.0, 1.0), yaw, 0.0), SimGround.flat())
var ahead: Vector3 = (walker.position - Vector3(500.0, 0.0, 500.0)).normalized()
assert_true(ahead.dot(-view.basis.z) > 0.99, "yaw %f: forward went %s" % [yaw, ahead])
func test_aiming_pulls_in_and_narrows() -> void:
var rig: CameraRig = CameraRig.new()
var feet: Vector3 = Vector3(100.0, 0.0, 100.0)
var hip: Transform3D = rig.solve(feet, 0.0, 0.0, false, SimGround.flat())
assert_eq(rig.fov(), CameraRig.FOV)
for _index: int in 60:
rig.update_aim(true, 1.0 / 60.0)
assert_eq(rig.aim_blend, 1.0)
var aimed: Transform3D = rig.solve(feet, 0.0, 0.0, false, SimGround.flat())
var pivot: Vector3 = CameraRig.pivot(feet, false)
assert_true(aimed.origin.distance_to(pivot) < hip.origin.distance_to(pivot))
assert_eq(rig.fov(), CameraRig.AIM_FOV)
rig.update_aim(false, 0.05)
assert_true(rig.aim_blend > 0.0 and rig.aim_blend < 1.0, "aim should ease, not snap")
func test_wall_behind_pulls_the_camera_in() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(90.0, 0.0, 98.0), Vector3(20.0, 4.0, 1.0)))
var view: Transform3D = CameraRig.new().solve(Vector3(100.0, 0.0, 100.0), 0.0, 0.0, false, ground)
assert_true(view.origin.z > 99.0 + CameraRig.CLEARANCE - 0.001, "camera at z %f is in the wall" % view.origin.z)
func test_scripted_sweep_never_clips() -> void:
var checked: int = 0
for arena: Array in _arenas():
var ground: SimGround = arena[0]
var feet: Vector3 = arena[1]
for crouching: bool in [false, true]:
for blend: float in [0.0, 1.0]:
var rig: CameraRig = CameraRig.new()
rig.aim_blend = blend
for yaw_step: int in 72:
for pitch_step: int in 17:
var yaw: float = yaw_step * TAU / 72.0
var pitch: float = deg_to_rad(-80.0 + pitch_step * 10.0)
var view: Transform3D = rig.solve(feet, yaw, pitch, crouching, ground)
var problem: String = _clipping(ground, view, rig.fov(), CameraRig.pivot(feet, crouching))
checked += 1
if not problem.is_empty():
fail("%s at yaw %d° pitch %d° crouch %s aim %s: %s" % [
arena[2], roundi(rad_to_deg(yaw)), roundi(rad_to_deg(pitch)),
crouching, blend, problem,
])
return
assert_eq(checked, 5 * 2 * 2 * 72 * 17)
## Returns why a view clips, or "" if it doesn't: the eye or a near-plane corner is
## inside geometry, or the line from the pivot to the eye passes through it.
func _clipping(ground: SimGround, view: Transform3D, fov_degrees: float, pivot: Vector3) -> String:
if ground.point_inside(view.origin):
return "eye inside geometry at %s" % view.origin
var half_height: float = CameraRig.NEAR * tan(deg_to_rad(fov_degrees) * 0.5)
var half_width: float = half_height * ASPECT
var centre: Vector3 = view.origin - view.basis.z * CameraRig.NEAR
for sx: float in [-1.0, 1.0]:
for sy: float in [-1.0, 1.0]:
var corner: Vector3 = centre + view.basis.x * half_width * sx + view.basis.y * half_height * sy
if ground.point_inside(corner):
return "near-plane corner inside geometry at %s" % corner
if ground.raycast(pivot, view.origin) < 1.0:
return "line of sight from the pivot is blocked"
return ""
## [ground, feet, name] for each place the sweep is run.
func _arenas() -> Array[Array]:
var arenas: Array[Array] = []
var wall: SimGround = SimGround.flat()
wall.add_solid(AABB(Vector3(90.0, 0.0, 100.0 + Tuning.PLAYER_RADIUS), Vector3(20.0, 4.0, 0.5)))
arenas.append([wall, Vector3(100.0, 0.0, 100.0), "against a wall"])
var corridor: SimGround = SimGround.flat()
corridor.add_solid(AABB(Vector3(98.0, 0.0, 80.0), Vector3(1.5, 4.0, 40.0)))
corridor.add_solid(AABB(Vector3(100.5, 0.0, 80.0), Vector3(1.5, 4.0, 40.0)))
arenas.append([corridor, Vector3(100.0, 0.0, 100.0), "in a narrow corridor"])
var roof: SimGround = SimGround.flat()
roof.add_solid(AABB(Vector3(90.0, 2.2, 90.0), Vector3(20.0, 0.3, 20.0)))
arenas.append([roof, Vector3(100.0, 0.0, 100.0), "under a low roof"])
var corner: SimGround = SimGround.flat()
corner.add_solid(AABB(Vector3(100.5, 0.0, 90.0), Vector3(3.0, 4.0, 20.0)))
corner.add_solid(AABB(Vector3(90.0, 0.0, 100.5), Vector3(20.0, 4.0, 3.0)))
arenas.append([corner, Vector3(100.0, 0.0, 100.0), "in a corner"])
var side: int = 64
var values: PackedFloat32Array = PackedFloat32Array()
values.resize(side * side)
for z: int in side:
for x: int in side:
# A steep bank rising to the east, with ripples.
values[z * side + x] = maxf(float(x) - 30.0, 0.0) * 1.8 + 0.4 * sin(z * 0.9)
var hill: SimGround = SimGround.from_heights(values, side, 1.0)
var foot: Vector3 = Vector3(29.6, 0.0, 32.0)
foot.y = hill.terrain_height(foot.x, foot.z)
arenas.append([hill, foot, "at the foot of a steep bank"])
return arenas
+1
View File
@@ -0,0 +1 @@
uid://dsempouxfbdom
+68
View File
@@ -0,0 +1,68 @@
extends TestCase
const PATH: String = "user://test_input_settings.cfg"
func after_each() -> void:
if FileAccess.file_exists(PATH):
DirAccess.remove_absolute(ProjectSettings.globalize_path(PATH))
func test_sensitivity_scales_turning() -> void:
var settings: InputSettings = InputSettings.new()
var slow: Vector2 = settings.apply_mouse(Vector2(100.0, 0.0), 1.0, 0.0, false)
settings.mouse_sensitivity = 2.0
var fast: Vector2 = settings.apply_mouse(Vector2(100.0, 0.0), 1.0, 0.0, false)
assert_near(1.0 - slow.x, 100.0 * InputSettings.RADIANS_PER_PIXEL, 0.00001)
assert_near(1.0 - fast.x, 2.0 * (1.0 - slow.x), 0.00001)
func test_mouse_right_turns_right_and_up_looks_up() -> void:
var settings: InputSettings = InputSettings.new()
var look: Vector2 = settings.apply_mouse(Vector2(10.0, -10.0), 1.0, 0.0, false)
assert_true(look.x < 1.0, "turning right decreases yaw")
assert_true(look.y > 0.0, "mouse up looks up")
settings.invert_y = true
assert_true(settings.apply_mouse(Vector2(0.0, -10.0), 1.0, 0.0, false).y < 0.0)
func test_aiming_slows_the_mouse() -> void:
var settings: InputSettings = InputSettings.new()
var hip: Vector2 = settings.apply_mouse(Vector2(50.0, 0.0), 1.0, 0.0, false)
var aimed: Vector2 = settings.apply_mouse(Vector2(50.0, 0.0), 1.0, 0.0, true)
assert_near(1.0 - aimed.x, (1.0 - hip.x) * settings.aim_sensitivity_scale, 0.00001)
func test_pitch_is_clamped_and_yaw_wraps() -> void:
var settings: InputSettings = InputSettings.new()
var look: Vector2 = settings.apply_mouse(Vector2(-10.0, -100000.0), TAU - 0.001, 0.0, false)
assert_near(look.y, InputSettings.PITCH_LIMIT, 0.00001)
assert_true(look.x >= 0.0 and look.x < TAU)
func test_sensitivity_is_clamped() -> void:
var settings: InputSettings = InputSettings.new()
settings.mouse_sensitivity = 0.0
assert_eq(settings.mouse_sensitivity, InputSettings.MIN_SENSITIVITY)
settings.mouse_sensitivity = 1000.0
assert_eq(settings.mouse_sensitivity, InputSettings.MAX_SENSITIVITY)
func test_settings_round_trip_through_the_config_file() -> void:
var settings: InputSettings = InputSettings.new()
settings.mouse_sensitivity = 2.75
settings.aim_sensitivity_scale = 0.4
settings.invert_y = true
assert_eq(settings.save(PATH), OK)
var loaded: InputSettings = InputSettings.load_from(PATH)
assert_near(loaded.mouse_sensitivity, 2.75, 0.0001)
assert_near(loaded.aim_sensitivity_scale, 0.4, 0.0001)
assert_true(loaded.invert_y)
func test_missing_or_bad_file_gives_defaults() -> void:
assert_eq(InputSettings.load_from("user://does_not_exist.cfg").mouse_sensitivity, 1.0)
var config: ConfigFile = ConfigFile.new()
config.set_value(InputSettings.SECTION, "mouse_sensitivity", "fast")
config.save(PATH)
assert_eq(InputSettings.load_from(PATH).mouse_sensitivity, 1.0)
+1
View File
@@ -0,0 +1 @@
uid://c517c7silhnhv
+275
View File
@@ -0,0 +1,275 @@
extends TestCase
## Yaw that faces +x, since forward is (sin yaw, 0, cos yaw).
const EAST: float = PI * 0.5
const NORTH: float = 0.0
var _tick: int = 0
func before_each() -> void:
_tick = 0
func _player(at: Vector3, on_ground: bool = true) -> SimEntity:
var player: SimEntity = SimEntity.new(1, SimEntity.ARCHETYPE_PLAYER)
player.position = at
player.health = Tuning.PLAYER_MAX_HEALTH
player.on_ground = on_ground
return player
func _command(move: Vector2, yaw: float, buttons: int = 0) -> PlayerCommand:
var command: PlayerCommand = PlayerCommand.from_input(_tick, move, yaw, 0.0, buttons)
_tick += 1
return command
func _run(player: SimEntity, ground: SimGround, ticks: int, move: Vector2, yaw: float, buttons: int = 0) -> void:
for _index: int in ticks:
Movement.step(player, _command(move, yaw, buttons), ground)
## A heightfield that is flat up to x = `start`, then rises at `degrees` along +x.
func _ramp(degrees: float, start: float = 10.0) -> SimGround:
var side: int = 64
var values: PackedFloat32Array = PackedFloat32Array()
values.resize(side * side)
var rise: float = tan(deg_to_rad(degrees))
for z: int in side:
for x: int in side:
values[z * side + x] = maxf(float(x) - start, 0.0) * rise
return SimGround.from_heights(values, side, 1.0)
func test_walk_sprint_and_crouch_speeds() -> void:
var ground: SimGround = SimGround.flat()
var cases: Array[Array] = [
[0, Tuning.WALK_SPEED],
[PlayerCommand.BUTTON_SPRINT, Tuning.SPRINT_SPEED],
[PlayerCommand.BUTTON_CROUCH, Tuning.CROUCH_SPEED],
[PlayerCommand.BUTTON_CROUCH | PlayerCommand.BUTTON_SPRINT, Tuning.CROUCH_SPEED],
]
for entry: Array in cases:
var player: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
_run(player, ground, Tuning.TICK_RATE_HZ, Vector2(0.0, 1.0), EAST, entry[0])
assert_near(player.position.x - 100.0, entry[1], 0.01, "buttons %d" % entry[0])
assert_near(player.position.z, 100.0, 0.001)
assert_eq(player.position.y, 0.0)
func test_sprint_only_applies_moving_forward() -> void:
var player: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
_run(player, SimGround.flat(), Tuning.TICK_RATE_HZ, Vector2(1.0, 0.0), NORTH, PlayerCommand.BUTTON_SPRINT)
assert_near(player.position.distance_to(Vector3(100.0, 0.0, 100.0)), Tuning.WALK_SPEED, 0.01)
func test_diagonal_is_no_faster_than_straight() -> void:
var player: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
_run(player, SimGround.flat(), Tuning.TICK_RATE_HZ, Vector2(1.0, 1.0), NORTH)
assert_near(player.position.distance_to(Vector3(100.0, 0.0, 100.0)), Tuning.WALK_SPEED, 0.05)
func test_jump_height_and_airtime() -> void:
var player: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
var ground: SimGround = SimGround.flat()
Movement.step(player, _command(Vector2.ZERO, NORTH, PlayerCommand.BUTTON_JUMP), ground)
assert_false(player.on_ground)
var peak: float = player.position.y
var ticks_in_air: int = 1
while not player.on_ground and ticks_in_air < 200:
Movement.step(player, _command(Vector2.ZERO, NORTH), ground)
peak = maxf(peak, player.position.y)
ticks_in_air += 1
var expected_peak: float = Tuning.JUMP_VELOCITY * Tuning.JUMP_VELOCITY / (2.0 * Tuning.GRAVITY)
assert_near(peak, expected_peak, 0.01, "jump height")
var expected_ticks: float = 2.0 * Tuning.JUMP_VELOCITY / Tuning.GRAVITY * Tuning.TICK_RATE_HZ
assert_near(ticks_in_air, expected_ticks, 1.5, "time in the air")
assert_eq(player.position.y, 0.0)
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH, "a jump on flat ground must not hurt")
func test_no_jump_while_crouched_or_in_the_air() -> void:
var ground: SimGround = SimGround.flat()
var crouched: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
Movement.step(crouched, _command(Vector2.ZERO, NORTH, PlayerCommand.BUTTON_JUMP | PlayerCommand.BUTTON_CROUCH), ground)
assert_true(crouched.on_ground)
assert_eq(crouched.position.y, 0.0)
var jumper: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
Movement.step(jumper, _command(Vector2.ZERO, NORTH, PlayerCommand.BUTTON_JUMP), ground)
var rising: float = jumper.velocity.y
Movement.step(jumper, _command(Vector2.ZERO, NORTH, PlayerCommand.BUTTON_JUMP), ground)
assert_true(jumper.velocity.y < rising, "a second jump in the air must not add speed")
func test_without_a_command_an_airborne_player_still_falls() -> void:
var player: SimEntity = _player(Vector3(100.0, 3.0, 100.0), false)
for _index: int in 30:
Movement.step(player, null, SimGround.flat())
assert_true(player.on_ground)
assert_eq(player.position.y, 0.0)
func test_walks_up_a_gentle_slope() -> void:
var player: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(player, _ramp(30.0), Tuning.TICK_RATE_HZ * 5, Vector2(0.0, 1.0), EAST)
assert_true(player.position.x > 20.0, "should have climbed well up the slope, at x %f" % player.position.x)
assert_near(player.position.y, (player.position.x - 10.0) * tan(deg_to_rad(30.0)), 0.05)
assert_true(player.on_ground)
func test_walks_down_a_gentle_slope_without_leaving_the_ground() -> void:
var player: SimEntity = _player(Vector3(30.0, 20.0 * tan(deg_to_rad(30.0)), 20.0))
for _index: int in Tuning.TICK_RATE_HZ * 4:
Movement.step(player, _command(Vector2(0.0, 1.0), -EAST), _ramp(30.0))
assert_true(player.on_ground, "lost the ground at x %f" % player.position.x)
assert_true(player.position.x < 15.0)
func test_too_steep_a_slope_blocks_walking_up() -> void:
var player: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(player, _ramp(60.0), Tuning.TICK_RATE_HZ * 5, Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_SPRINT)
assert_true(player.position.x < 11.0, "climbed a 60 degree slope to x %f" % player.position.x)
assert_true(player.position.y < 1.0)
func test_cannot_climb_a_steep_slope_by_jumping_into_it() -> void:
var player: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
var ground: SimGround = _ramp(60.0)
for _index: int in Tuning.TICK_RATE_HZ * 6:
Movement.step(player, _command(Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_JUMP), ground)
assert_true(player.position.y < 3.0, "jumped up a cliff to height %f" % player.position.y)
func test_slides_down_ground_too_steep_to_stand_on() -> void:
var ground: SimGround = _ramp(60.0)
var x: float = 20.0
var player: SimEntity = _player(Vector3(x, ground.terrain_height(x, 20.0), 20.0))
for _index: int in Tuning.TICK_RATE_HZ * 5:
Movement.step(player, null, ground)
assert_true(player.position.x < 10.5, "should have slid to the foot, at x %f" % player.position.x)
assert_true(player.on_ground)
assert_eq(player.health, Tuning.PLAYER_MAX_HEALTH, "a capped slide must not hurt")
func test_steps_up_low_ledges_but_not_high_ones() -> void:
var low: SimGround = SimGround.flat()
low.add_solid(AABB(Vector3(10.0, 0.0, 0.0), Vector3(4.0, Tuning.STEP_HEIGHT - 0.05, 40.0)))
var player: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(player, low, Tuning.TICK_RATE_HZ * 2, Vector2(0.0, 1.0), EAST)
assert_true(player.position.x > 10.0)
assert_near(player.position.y, Tuning.STEP_HEIGHT - 0.05, 0.001)
var high: SimGround = SimGround.flat()
high.add_solid(AABB(Vector3(10.0, 0.0, 0.0), Vector3(4.0, 1.0, 40.0)))
var blocked: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(blocked, high, Tuning.TICK_RATE_HZ * 2, Vector2(0.0, 1.0), EAST)
assert_near(blocked.position.x, 10.0 - Tuning.PLAYER_RADIUS, 0.15)
assert_eq(blocked.position.y, 0.0)
func test_jumps_onto_a_ledge_too_high_to_step() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(10.0, 0.0, 0.0), Vector3(4.0, 1.0, 40.0)))
var player: SimEntity = _player(Vector3(8.0, 0.0, 20.0))
_run(player, ground, 1, Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_JUMP)
_run(player, ground, Tuning.TICK_RATE_HZ, Vector2(0.0, 1.0), EAST)
assert_true(player.position.x > 10.0)
assert_near(player.position.y, 1.0, 0.001)
func test_slides_along_a_wall() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(10.0, 0.0, 0.0), Vector3(1.0, 3.0, 100.0)))
var player: SimEntity = _player(Vector3(9.0, 0.0, 20.0))
# North-east, into the wall: x stops, z keeps going.
_run(player, ground, Tuning.TICK_RATE_HZ, Vector2(0.0, 1.0), PI * 0.25)
assert_true(player.position.x <= 10.0 - Tuning.PLAYER_RADIUS + 0.001)
assert_true(player.position.z > 22.0)
func test_ceiling_stops_a_jump() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(95.0, 2.2, 95.0), Vector3(10.0, 0.5, 10.0)))
var player: SimEntity = _player(Vector3(100.0, 0.0, 100.0))
var top: float = 0.0
for _index: int in 40:
Movement.step(player, _command(Vector2.ZERO, NORTH, PlayerCommand.BUTTON_JUMP), ground)
top = maxf(top, player.position.y + Tuning.PLAYER_HEIGHT)
assert_true(top <= 2.2 + 0.001, "head reached %f, through the ceiling" % top)
func test_crouching_fits_under_a_low_gap() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(10.0, 1.5, 0.0), Vector3(4.0, 1.0, 40.0)))
var standing: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(standing, ground, Tuning.TICK_RATE_HZ * 3, Vector2(0.0, 1.0), EAST)
assert_true(standing.position.x < 10.0)
var crouched: SimEntity = _player(Vector3(5.0, 0.0, 20.0))
_run(crouched, ground, Tuning.TICK_RATE_HZ * 5, Vector2(0.0, 1.0), EAST, PlayerCommand.BUTTON_CROUCH)
assert_true(crouched.position.x > 14.0)
func test_fall_damage() -> void:
var cases: Array[Array] = [[3.0, 0], [6.0, 0], [10.0, 32], [16.0, 80]]
for entry: Array in cases:
var player: SimEntity = _player(Vector3(100.0, entry[0], 100.0), false)
for _index: int in 90:
Movement.step(player, null, SimGround.flat())
var damage: int = Tuning.PLAYER_MAX_HEALTH - player.health
assert_near(damage, entry[1], 3.0, "drop of %f m" % entry[0])
assert_true(player.on_ground)
func test_fall_damage_never_goes_below_zero_health() -> void:
var player: SimEntity = _player(Vector3(100.0, 80.0, 100.0), false)
for _index: int in 200:
Movement.step(player, null, SimGround.flat())
assert_eq(player.health, 0)
func test_stands_on_a_solid_and_falls_off_its_edge() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(0.0, 0.0, 0.0), Vector3(10.0, 3.0, 40.0)))
var player: SimEntity = _player(Vector3(5.0, 3.0, 20.0))
_run(player, ground, Tuning.TICK_RATE_HZ * 3, Vector2(0.0, 1.0), EAST)
assert_true(player.position.x > 10.0)
assert_eq(player.position.y, 0.0)
assert_true(player.on_ground)
func test_same_commands_on_rough_ground_are_deterministic() -> void:
var first: Simulation = _rough_simulation()
var second: Simulation = _rough_simulation()
var random: RandomNumberGenerator = RandomNumberGenerator.new()
random.seed = 77
for at_tick: int in 1500:
for id: int in [1, 2, 3, 4]:
var command: PlayerCommand = PlayerCommand.new()
command.tick = at_tick
command.move_x = random.randi_range(-127, 127)
command.move_y = random.randi_range(-127, 127)
command.yaw = random.randi_range(0, 65535)
command.buttons = random.randi_range(0, 31)
first.submit_command(id, command)
second.submit_command(id, command)
first.step()
second.step()
assert_eq(first.state_hash(), second.state_hash())
func _rough_simulation() -> Simulation:
var sim: Simulation = Simulation.new(4242)
var side: int = 65
var values: PackedFloat32Array = PackedFloat32Array()
values.resize(side * side)
for z: int in side:
for x: int in side:
values[z * side + x] = 6.0 * sin(x * 0.31) * cos(z * 0.23) + 0.08 * x
sim.ground = SimGround.from_heights(values, side, 16.0)
for index: int in 12:
sim.ground.add_solid(AABB(Vector3(index * 70.0, 0.0, 500.0), Vector3(4.0, 3.0 + index, 4.0)))
for _index: int in 4:
sim.add_player()
return sim
+1
View File
@@ -0,0 +1 @@
uid://p72o0ughjt1a
+85
View File
@@ -0,0 +1,85 @@
extends TestCase
func _tilted() -> SimGround:
# h = 0.5 * x, a plane rising along +x.
var values: PackedFloat32Array = PackedFloat32Array()
for z: int in 4:
for x: int in 4:
values.append(0.5 * x * 2.0)
return SimGround.from_heights(values, 4, 2.0)
func test_flat_ground() -> void:
var ground: SimGround = SimGround.flat(3.0)
assert_eq(ground.terrain_height(10.0, 900.0), 3.0)
assert_true(ground.terrain_normal(10.0, 10.0).is_equal_approx(Vector3.UP))
assert_true(ground.walkable_terrain(10.0, 10.0))
func test_interpolation_and_edges() -> void:
var ground: SimGround = _tilted()
assert_near(ground.terrain_height(1.0, 1.0), 0.5, 0.0001)
assert_near(ground.terrain_height(3.0, 5.0), 1.5, 0.0001)
# Outside the grid, the edge sample is used.
assert_near(ground.terrain_height(-5.0, 2.0), 0.0, 0.0001)
assert_near(ground.terrain_height(100.0, 2.0), 3.0, 0.0001)
func test_normal_and_walkability() -> void:
var ground: SimGround = _tilted()
var normal: Vector3 = ground.terrain_normal(3.0, 3.0)
assert_near(rad_to_deg(normal.angle_to(Vector3.UP)), rad_to_deg(atan(0.5)), 0.01)
assert_true(normal.x < 0.0, "the normal leans away from the rise")
assert_true(ground.walkable_terrain(3.0, 3.0))
func test_support_from_solids() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(0.0, 0.0, 0.0), Vector3(2.0, 1.0, 2.0)))
ground.add_solid(AABB(Vector3(0.0, 5.0, 0.0), Vector3(2.0, 1.0, 2.0)))
assert_eq(ground.support_height(1.0, 1.0, 1.2), 1.0)
assert_eq(ground.support_height(1.0, 1.0, 10.0), 6.0)
assert_eq(ground.support_height(1.0, 1.0, 0.5), 0.0)
assert_eq(ground.support_height(3.0, 1.0, 10.0), 0.0)
assert_true(ground.support_is_solid(1.0, 1.0, 1.2))
assert_false(ground.support_is_solid(3.0, 1.0, 1.2))
func test_negative_size_solids_are_normalised() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(2.0, 1.0, 2.0), Vector3(-2.0, -1.0, -2.0)))
assert_eq(ground.support_height(1.0, 1.0, 5.0), 1.0)
func test_raycast_against_a_box() -> void:
var ground: SimGround = SimGround.flat(-100.0)
ground.add_solid(AABB(Vector3(4.0, -1.0, -1.0), Vector3(2.0, 2.0, 2.0)))
assert_near(ground.raycast(Vector3.ZERO, Vector3(10.0, 0.0, 0.0)), 0.4, 0.0001)
assert_eq(ground.raycast(Vector3.ZERO, Vector3(3.0, 0.0, 0.0)), 1.0)
assert_eq(ground.raycast(Vector3(0.0, 5.0, 0.0), Vector3(10.0, 5.0, 0.0)), 1.0)
assert_eq(ground.raycast(Vector3(5.0, 0.0, 0.0), Vector3(10.0, 0.0, 0.0)), 0.0, "starting inside")
func test_raycast_against_terrain() -> void:
var ground: SimGround = SimGround.flat(0.0)
var hit: float = ground.raycast(Vector3(0.0, 2.0, 0.0), Vector3(0.0, -2.0, 0.0))
assert_near(hit, 0.5, 0.001)
assert_eq(ground.raycast(Vector3(0.0, 2.0, 0.0), Vector3(5.0, 1.0, 0.0)), 1.0)
assert_eq(ground.raycast(Vector3(0.0, -1.0, 0.0), Vector3(0.0, 3.0, 0.0)), 0.0, "starting below")
# A ray grazing up a slope finds where it enters.
var tilted: SimGround = _tilted()
var slope_hit: float = tilted.raycast(Vector3(0.0, 2.0, 2.0), Vector3(6.0, 2.0, 2.0))
assert_near(slope_hit * 6.0, 4.0, 0.01)
func test_body_blocked_respects_step_and_height() -> void:
var ground: SimGround = SimGround.flat()
ground.add_solid(AABB(Vector3(0.0, 0.0, 0.0), Vector3(2.0, 0.4, 2.0)))
ground.add_solid(AABB(Vector3(10.0, 2.0, 0.0), Vector3(2.0, 1.0, 2.0)))
assert_false(ground.body_blocked(Vector3(1.0, 0.0, 1.0), 0.4, 1.8, 0.45), "low step")
assert_true(ground.body_blocked(Vector3(1.0, 0.0, 1.0), 0.4, 1.8, 0.0))
assert_true(ground.body_blocked(Vector3(2.3, 0.0, 1.0), 0.4, 1.8, 0.0), "radius overlaps")
assert_false(ground.body_blocked(Vector3(2.5, 0.0, 1.0), 0.4, 1.8, 0.0))
assert_false(ground.body_blocked(Vector3(11.0, 0.0, 1.0), 0.4, 1.8, 0.0), "fits under")
assert_true(ground.body_blocked(Vector3(11.0, 0.0, 1.0), 0.4, 2.5, 0.0))
+1
View File
@@ -0,0 +1 @@
uid://b2yuyo1vyam3j
+3 -2
View File
@@ -21,8 +21,9 @@ func test_a_different_seed_changes_the_hash() -> void:
func test_a_single_changed_command_changes_the_hash() -> void:
var log_bytes: PackedByteArray = _build_command_log(SEED, 4, 200)
var changed: PackedByteArray = log_bytes.duplicate()
# Flip one bit of move_x in the middle of the log.
changed[changed.size() / 2 / PlayerCommand.ENCODED_SIZE * PlayerCommand.ENCODED_SIZE + 4] ^= 1
# Flip a high bit of move_x in the middle of the log. The lowest bit is a 1/127 nudge
# of the stick, which moves an airborne player less than the hash's millimetre.
changed[changed.size() / 2 / PlayerCommand.ENCODED_SIZE * PlayerCommand.ENCODED_SIZE + 4] ^= 0x40
assert_ne(_replay(SEED, log_bytes, 4), _replay(SEED, changed, 4))