Top-down twin-stick bullet-hell, Godot 4.7, server-authoritative dedicated server with client-side prediction. Clients send input only; the server resolves every hit for both players and enemies (no PvP). - SimWorld: whole simulation as plain RefCounted objects (no nodes, no physics server), ~0.24ms/tick at peak load -- runs headless for free and drives 78 tests in under a second - BulletPool: struct-of-arrays bullet storage, replicated as spawn/despawn events rather than per-tick state - Emitter framework (Ring/AimedSpread/WallGap/ArcSweep) shared by trash enemies and bosses -- a new boss is data in src/content/content.gd, no simulation changes - The Warden of the Fold: stationary 4-phase boss built entirely on that format - Lobby hub with a portal into on-demand dungeon instances; one process hosts the hub plus every concurrent dungeon - Emergency escape: 3s server-owned channel, cancelled by damage - tools/check.sh, test.sh (GUT), smoke.sh (real server + bot clients over ENet), bench.gd; git hooks wired to the same scripts - docs/ARCHITECTURE.md, NETCODE.md, WORKFLOW.md, ROADMAP.md
This commit is contained in:
Adyrem
@@ -0,0 +1,252 @@
|
||||
class_name ClientRuntime
|
||||
extends Node
|
||||
## The client half: sample input, predict the local player, interpolate everyone
|
||||
## else, and replay the bullets the server told us about.
|
||||
##
|
||||
## The client owns exactly one thing -- where it *thinks* the local player is,
|
||||
## so the stick feels instant. Every consequence (damage, death, escape, loot)
|
||||
## comes back from the server and overwrites whatever the client believed.
|
||||
|
||||
signal instance_changed
|
||||
signal hud_dirty
|
||||
signal local_hit(damage: int)
|
||||
|
||||
var my_peer: int = 0
|
||||
var instance_id: int = 0
|
||||
var instance_kind: Protocol.InstanceKind = Protocol.InstanceKind.LOBBY
|
||||
var boss_def: BossDef = null
|
||||
|
||||
## Replica world. [member SimWorld.authoritative] is false, so it integrates
|
||||
## bullets and nothing else.
|
||||
var world := SimWorld.new()
|
||||
|
||||
## Local estimate of the server's tick, used to age incoming bullets.
|
||||
var server_tick_est: int = 0
|
||||
var input_tick: int = 0
|
||||
|
||||
var predicted_pos := Vector2.ZERO
|
||||
var aim: float = 0.0
|
||||
var pending: Array[InputFrame] = []
|
||||
|
||||
# Authoritative mirror of the local player.
|
||||
var my_hp: int = SimConfig.PLAYER_MAX_HP
|
||||
var my_alive: bool = true
|
||||
var my_escape: float = 0.0
|
||||
var my_escaping: bool = false
|
||||
|
||||
var snap_prev: Dictionary = {}
|
||||
var snap_curr: Dictionary = {}
|
||||
var _interp: float = 0.0
|
||||
var _bot_tick: int = 0
|
||||
|
||||
|
||||
func _ready() -> void:
|
||||
world.authoritative = false
|
||||
set_physics_process(true)
|
||||
|
||||
|
||||
func _physics_process(delta: float) -> void:
|
||||
server_tick_est += 1
|
||||
input_tick += 1
|
||||
|
||||
var frame := _sample_input()
|
||||
pending.append(frame)
|
||||
# Only enough history to cover the worst reconciliation window.
|
||||
while pending.size() > SimConfig.INPUT_MAX_AGE:
|
||||
pending.pop_front()
|
||||
|
||||
if my_alive:
|
||||
predicted_pos = Movement.step_player(predicted_pos, frame.move,
|
||||
SimConfig.PLAYER_SPEED, SimConfig.ARENA_HALF)
|
||||
|
||||
# Send the last few frames every tick. Inputs are unreliable-ordered, so the
|
||||
# redundancy is what covers a dropped packet without a retransmit stall.
|
||||
var redundant: Array[InputFrame] = []
|
||||
var from := maxi(pending.size() - 3, 0)
|
||||
for i in range(from, pending.size()):
|
||||
redundant.append(pending[i])
|
||||
Net.send_input(NetCodec.encode_inputs(redundant))
|
||||
|
||||
world.step()
|
||||
_interp = minf(_interp + delta * float(SimConfig.TICK_RATE) / float(SimConfig.SNAPSHOT_INTERVAL), 1.0)
|
||||
|
||||
|
||||
# --- Input ------------------------------------------------------------------
|
||||
|
||||
func _sample_input() -> InputFrame:
|
||||
if GameOpts.bot_client:
|
||||
return _bot_input()
|
||||
var move := Input.get_vector("move_left", "move_right", "move_up", "move_down")
|
||||
var mouse := get_viewport().get_mouse_position() - get_viewport().get_visible_rect().size * 0.5
|
||||
var to_mouse := mouse - predicted_pos
|
||||
if to_mouse.length_squared() > 1.0:
|
||||
aim = to_mouse.angle()
|
||||
var buttons := 0
|
||||
if Input.is_action_pressed("fire"):
|
||||
buttons |= InputFrame.BTN_FIRE
|
||||
if Input.is_action_pressed("emergency_escape"):
|
||||
buttons |= InputFrame.BTN_ESCAPE
|
||||
if Input.is_action_pressed("interact"):
|
||||
buttons |= InputFrame.BTN_INTERACT
|
||||
return InputFrame.make(input_tick, move, aim, buttons)
|
||||
|
||||
|
||||
## Scripted input so `tools/smoke.sh` can play the game with no display: orbit
|
||||
## the arena, fire constantly, take the portal, then punch out with the escape.
|
||||
func _bot_input() -> InputFrame:
|
||||
_bot_tick += 1
|
||||
var t := float(_bot_tick) * SimConfig.TICK_DELTA
|
||||
var move := Vector2(cos(t * 0.9), sin(t * 1.3))
|
||||
aim = t * 2.1
|
||||
var buttons := InputFrame.BTN_FIRE
|
||||
if instance_kind == Protocol.InstanceKind.LOBBY and _bot_tick % 120 < 30:
|
||||
buttons |= InputFrame.BTN_INTERACT
|
||||
# Walk onto the portal instead of orbiting, or interact never lands.
|
||||
move = (SimConfig.PORTAL_POS - predicted_pos).normalized()
|
||||
if instance_kind == Protocol.InstanceKind.DUNGEON and _bot_tick > 900:
|
||||
buttons |= InputFrame.BTN_ESCAPE
|
||||
return InputFrame.make(input_tick, move, aim, buttons)
|
||||
|
||||
|
||||
# --- Server messages --------------------------------------------------------
|
||||
|
||||
func on_welcome(peer_id: int) -> void:
|
||||
my_peer = peer_id
|
||||
set_physics_process(true)
|
||||
GameLog.info("client", "welcome, peer id %d" % peer_id)
|
||||
|
||||
|
||||
func on_enter_instance(id: int, kind: int, server_tick: int, boss_id: String,
|
||||
spawn: Vector2) -> void:
|
||||
instance_id = id
|
||||
instance_kind = kind as Protocol.InstanceKind
|
||||
boss_def = Content.boss(StringName(boss_id)) if not boss_id.is_empty() else null
|
||||
world.pool.clear()
|
||||
snap_prev = {}
|
||||
snap_curr = {}
|
||||
predicted_pos = spawn
|
||||
pending.clear()
|
||||
server_tick_est = server_tick
|
||||
input_tick = server_tick + 8
|
||||
my_alive = true
|
||||
my_hp = SimConfig.PLAYER_MAX_HP
|
||||
my_escape = 0.0
|
||||
my_escaping = false
|
||||
GameLog.info("client", "entered instance %d (%s)" % [id, Protocol.InstanceKind.keys()[kind]])
|
||||
instance_changed.emit()
|
||||
hud_dirty.emit()
|
||||
|
||||
|
||||
func on_snapshot(data: PackedByteArray) -> void:
|
||||
var snap := NetCodec.decode_snapshot(data)
|
||||
if not snap_curr.is_empty() and int(snap["tick"]) <= int(snap_curr["tick"]):
|
||||
return # stale or duplicate; unreliable channel, newest wins
|
||||
snap_prev = snap_curr
|
||||
snap_curr = snap
|
||||
_interp = 0.0
|
||||
|
||||
var tick := int(snap["tick"])
|
||||
if server_tick_est < tick or server_tick_est > tick + 12:
|
||||
server_tick_est = tick
|
||||
# Keep the client roughly one buffer ahead of the server so inputs arrive
|
||||
# just before they are needed rather than late.
|
||||
var lead := input_tick - tick
|
||||
if lead < 2 or lead > 16:
|
||||
input_tick = tick + 8
|
||||
|
||||
for rec: Dictionary in snap["players"]:
|
||||
if int(rec["peer"]) == my_peer:
|
||||
_reconcile(rec)
|
||||
break
|
||||
|
||||
|
||||
## Rewind to the server's position, replay every input it has not seen yet, and
|
||||
## land where the client should actually be right now.
|
||||
func _reconcile(rec: Dictionary) -> void:
|
||||
my_hp = int(rec["hp"])
|
||||
my_alive = (int(rec["flags"]) & Protocol.F_ALIVE) != 0
|
||||
my_escaping = (int(rec["flags"]) & Protocol.F_ESCAPING) != 0
|
||||
my_escape = float(rec["escape"])
|
||||
hud_dirty.emit()
|
||||
|
||||
var acked := int(rec["last_input_tick"])
|
||||
while not pending.is_empty() and pending[0].tick <= acked:
|
||||
pending.pop_front()
|
||||
|
||||
var p: Vector2 = rec["pos"]
|
||||
if my_alive:
|
||||
for f in pending:
|
||||
p = Movement.step_player(p, f.move, SimConfig.PLAYER_SPEED, SimConfig.ARENA_HALF)
|
||||
var error := predicted_pos.distance_to(p)
|
||||
if error > 24.0:
|
||||
predicted_pos = p # real divergence: take the server's word
|
||||
elif error > 0.5:
|
||||
predicted_pos = predicted_pos.lerp(p, 0.3) # smooth out jitter
|
||||
|
||||
|
||||
func on_events(data: PackedByteArray) -> void:
|
||||
var packet := NetCodec.decode_events(data)
|
||||
var catchup := clampi(server_tick_est - int(packet["tick"]), 0, 30)
|
||||
for ev: Dictionary in packet["events"]:
|
||||
match int(ev["t"]):
|
||||
SimEvent.Type.BULLET_SPAWN:
|
||||
var slot := world.pool.spawn(ev["pos"], ev["vel"], ev["r"], ev["life"], 0,
|
||||
ev["team"], ev["kind"], ev["accel"], ev["turn"], ev["uid"])
|
||||
if slot >= 0 and catchup > 0:
|
||||
world.pool.advance_slot(slot, catchup)
|
||||
SimEvent.Type.BULLET_DESPAWN:
|
||||
world.apply_event(ev)
|
||||
SimEvent.Type.PLAYER_HIT:
|
||||
if int(ev["peer"]) == my_peer:
|
||||
my_hp = int(ev["hp"])
|
||||
local_hit.emit(int(ev["dmg"]))
|
||||
hud_dirty.emit()
|
||||
SimEvent.Type.PLAYER_DIED:
|
||||
if int(ev["peer"]) == my_peer:
|
||||
my_alive = false
|
||||
hud_dirty.emit()
|
||||
SimEvent.Type.PLAYER_RESPAWNED:
|
||||
if int(ev["peer"]) == my_peer:
|
||||
my_alive = true
|
||||
predicted_pos = ev["pos"]
|
||||
pending.clear()
|
||||
hud_dirty.emit()
|
||||
_:
|
||||
pass
|
||||
|
||||
|
||||
# --- View queries -----------------------------------------------------------
|
||||
|
||||
## Remote players, interpolated between the last two snapshots. The local player
|
||||
## is excluded -- the view draws [member predicted_pos] for that one.
|
||||
func remote_players() -> Array[Dictionary]:
|
||||
return _interpolated("players", "peer", [my_peer])
|
||||
|
||||
|
||||
func enemies() -> Array[Dictionary]:
|
||||
return _interpolated("enemies", "id", [])
|
||||
|
||||
|
||||
func boss_state() -> Dictionary:
|
||||
if snap_curr.is_empty() or snap_curr.get("boss") == null:
|
||||
return {}
|
||||
return snap_curr["boss"]
|
||||
|
||||
|
||||
func _interpolated(list_key: String, id_key: String, exclude: Array) -> Array[Dictionary]:
|
||||
var out: Array[Dictionary] = []
|
||||
if snap_curr.is_empty():
|
||||
return out
|
||||
var prev_by_id := {}
|
||||
if not snap_prev.is_empty():
|
||||
for r: Dictionary in snap_prev[list_key]:
|
||||
prev_by_id[r[id_key]] = r
|
||||
for r: Dictionary in snap_curr[list_key]:
|
||||
if exclude.has(r[id_key]):
|
||||
continue
|
||||
var rec: Dictionary = r.duplicate()
|
||||
var old: Variant = prev_by_id.get(r[id_key])
|
||||
if old != null:
|
||||
rec["pos"] = (old["pos"] as Vector2).lerp(r["pos"], _interp)
|
||||
out.append(rec)
|
||||
return out
|
||||
Reference in New Issue
Block a user