The client program now turns a connection into a match someone can play. - ClientSession: a ClientGame, the keyboard and mouse as commands (ClientInput), and a MatchView of the client's own copy of the world. - ClientMirror writes what the client is showing into that world every frame: other players from the recent past, its own player where it was predicted, items, the barge, the clock and the sea. The existing views draw it unchanged. - LocalServer: offline play is the same ServerLoop and NetGame in the same process, with packets handed across in memory, so there is one path. - main.gd: --connect=HOST[:PORT] joins a server, otherwise an offline match; --autoplay and --client-seconds=N for scripts and checks. - The camera aboard the barge follows the player's own place on the deck. Tests drive a scripted client through a whole match on a real server over loopback UDP, lobby to results, and through an offline match. `make client-check` does it with two real processes, and `make client-captures` renders what the client sees. Closes #77 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
157 lines
5.9 KiB
GDScript
157 lines
5.9 KiB
GDScript
## The client's picture of one match: sky, sun, terrain, sea, points of interest, props,
|
|
## built pieces and everything that moves, all drawn from one Simulation, with the
|
|
## third-person camera on a player's shoulder. It only reads the simulation.
|
|
##
|
|
## A match gets a new Simulation, so it gets a new MatchView. In play the simulation is
|
|
## the client's own copy of the world, which ClientMirror fills with what the server
|
|
## has sent; captures and tests also point it at a server's or a replay's.
|
|
class_name MatchView
|
|
extends Node3D
|
|
|
|
var sim: Simulation
|
|
var terrain: TerrainView
|
|
var water: WaterView
|
|
var pois: PoiView
|
|
var props: PropView
|
|
var structures: StructureView
|
|
var entities: EntityView
|
|
var camera: Camera3D
|
|
var rig: CameraRig = CameraRig.new()
|
|
|
|
|
|
## Builds the scene for `simulation`. `local_id` is the player this client plays, or 0.
|
|
func setup(simulation: Simulation, local_id: int = 0) -> void:
|
|
sim = simulation
|
|
var sky_material: ProceduralSkyMaterial = ProceduralSkyMaterial.new()
|
|
sky_material.sky_top_color = Color(0.32, 0.5, 0.68)
|
|
sky_material.sky_horizon_color = Color(0.82, 0.78, 0.68)
|
|
sky_material.ground_bottom_color = Color(0.18, 0.2, 0.2)
|
|
sky_material.ground_horizon_color = Color(0.82, 0.78, 0.68)
|
|
var sky: Sky = Sky.new()
|
|
sky.sky_material = sky_material
|
|
var environment: Environment = Environment.new()
|
|
environment.background_mode = Environment.BG_SKY
|
|
environment.sky = sky
|
|
environment.ambient_light_source = Environment.AMBIENT_SOURCE_SKY
|
|
environment.ambient_light_energy = 0.45
|
|
environment.tonemap_mode = Environment.TONE_MAPPER_FILMIC
|
|
environment.fog_enabled = true
|
|
environment.fog_light_color = Color(0.78, 0.78, 0.74)
|
|
environment.fog_density = 0.0005
|
|
environment.fog_aerial_perspective = 0.4
|
|
var world: WorldEnvironment = WorldEnvironment.new()
|
|
world.environment = environment
|
|
add_child(world)
|
|
var sun: DirectionalLight3D = DirectionalLight3D.new()
|
|
sun.rotation_degrees = Vector3(-35.0, -130.0, 0.0)
|
|
sun.light_energy = 0.95
|
|
sun.shadow_enabled = true
|
|
sun.directional_shadow_max_distance = 400.0
|
|
add_child(sun)
|
|
|
|
camera = Camera3D.new()
|
|
camera.near = CameraRig.NEAR
|
|
camera.far = 2500.0
|
|
camera.fov = CameraRig.FOV
|
|
add_child(camera)
|
|
camera.make_current()
|
|
|
|
if sim.island != null:
|
|
terrain = TerrainView.new()
|
|
terrain.setup(sim.island)
|
|
add_child(terrain)
|
|
water = WaterView.new()
|
|
add_child(water)
|
|
pois = PoiView.new()
|
|
pois.setup(sim.pois)
|
|
add_child(pois)
|
|
props = PropView.new()
|
|
props.setup(sim.props)
|
|
add_child(props)
|
|
structures = StructureView.new()
|
|
structures.setup(sim.structures)
|
|
add_child(structures)
|
|
entities = EntityView.new()
|
|
entities.local_id = local_id
|
|
entities.setup(sim)
|
|
add_child(entities)
|
|
sync()
|
|
|
|
|
|
## Matches everything drawn to the simulation as it is now.
|
|
func sync() -> void:
|
|
water.follow(sim)
|
|
props.sync()
|
|
structures.sync()
|
|
entities.sync()
|
|
|
|
|
|
## Puts the camera on a player's shoulder, looking where they look. `pitch` replaces
|
|
## their own pitch when given, in radians, for views such as looking down from a glide,
|
|
## and `look_yaw` their yaw, for the local player, whose look is newer than any command.
|
|
func follow(entity_id: int, pitch: float = NAN, look_yaw: float = NAN) -> bool:
|
|
var player: SimEntity = sim.entities.find(entity_id)
|
|
if player == null:
|
|
return false
|
|
var yaw: float = look_yaw if not is_nan(look_yaw) else float(player.yaw) / PlayerCommand.YAW_STEPS * TAU
|
|
var look_pitch: float = pitch if not is_nan(pitch) else float(player.pitch) / PlayerCommand.PITCH_MAX * (PI * 0.5)
|
|
# Where the figure is drawn: on the barge's deck that is its own place, not the
|
|
# one point the simulation carries every passenger at.
|
|
var feet: Vector3 = player.position
|
|
var figure: Node3D = entities.figure_of(entity_id)
|
|
if figure != null and player.drop_state == Drop.ABOARD:
|
|
feet = figure.position
|
|
camera.transform = rig.solve(feet, yaw, look_pitch, player.crouching, sim.ground)
|
|
camera.fov = rig.fov()
|
|
_focus()
|
|
return true
|
|
|
|
|
|
## Frames a player from outside: the camera stands `distance` metres off at `height`
|
|
## above their feet and looks at them, from the first of eight directions that has a
|
|
## clear line and no prop around the lens. With `beyond` given, it starts on the far
|
|
## side of the player from that point, so the point is in the picture behind them.
|
|
func frame(entity_id: int, distance: float = 6.0, height: float = 2.6, beyond: Vector3 = Vector3.INF) -> bool:
|
|
var player: SimEntity = sim.entities.find(entity_id)
|
|
if player == null:
|
|
return false
|
|
var chest: Vector3 = player.position + Vector3(0.0, 1.2, 0.0)
|
|
var first: float = float(player.yaw) / PlayerCommand.YAW_STEPS * TAU + PI
|
|
if beyond != Vector3.INF:
|
|
first = atan2(player.position.x - beyond.x, player.position.z - beyond.z)
|
|
var eye: Vector3 = chest
|
|
for turn: int in 8:
|
|
# Straight on first, then alternately to each side.
|
|
var angle: float = first + (turn + 1) / 2 * (PI / 4.0) * (1.0 if turn % 2 == 1 else -1.0)
|
|
eye = player.position + Vector3(sin(angle) * distance, height, cos(angle) * distance)
|
|
eye.y = maxf(eye.y, sim.ground.terrain_height(eye.x, eye.z) + 1.0)
|
|
var feet: Vector3 = Vector3(eye.x, sim.ground.terrain_height(eye.x, eye.z), eye.z)
|
|
if sim.ground.raycast(chest, eye) >= 1.0 and sim.props.near(feet, 5.0).is_empty():
|
|
break
|
|
look_from(eye, chest if beyond == Vector3.INF else chest.lerp(beyond, 0.35))
|
|
return true
|
|
|
|
|
|
## Puts the camera at `eye`, looking at `target`.
|
|
func look_from(eye: Vector3, target: Vector3) -> void:
|
|
camera.transform = Transform3D(Basis.IDENTITY, eye).looking_at(target, Vector3.UP)
|
|
camera.fov = CameraRig.FOV
|
|
_focus()
|
|
|
|
|
|
## The whole island from high over its south-west, as the lobby shows it.
|
|
func overview() -> void:
|
|
var size: float = Tuning.WORLD_SIZE_METRES
|
|
look_from(Vector3(size * 0.2, 300.0, size * 0.92), Vector3(size * 0.5, 0.0, size * 0.47))
|
|
|
|
|
|
## Builds every terrain chunk for the current camera at once. For loading and captures.
|
|
func settle() -> void:
|
|
if terrain != null:
|
|
terrain.build_all_now()
|
|
|
|
|
|
func _focus() -> void:
|
|
if terrain != null:
|
|
terrain.focus = camera.position
|