## The client's side of WORLD and OWN messages (see NetWorld): keeps the client's copy ## of the match's world, a Simulation that is never stepped, in line with the server's, ## and places the client's own pieces before the server has answered. ## ## What is kept in line: built pieces (with their health and building), props' health, ## opened chests, unspilled crates and the tide's schedule. NetWorld.world_hash() of ## the client's world equals the server's once every message up to a tick has been ## applied and sync() has been called for that tick. ## ## Placing ahead of the server: when the player places a piece and the client's own ## check passes, a provisional piece goes into the world at once, under an ID the ## server never uses, and its cost is held back from the materials shown. The server's ## piece arriving in the same slot replaces it. If a snapshot from after the placing ## tick has arrived, the world messages it speaks of have all arrived too, and no ## piece came, the server turned it down and the provisional piece is taken away. class_name ClientWorld extends RefCounted ## Provisional pieces get IDs from here up. const PROVISIONAL_FIRST_ID: int = 1 << 30 var world: Simulation = null ## The newest WORLD applied: its number (-1 before the first full one) and tick. var seq: int = -1 var tick: int = 0 ## True once anything has been applied that a new match would have to undo. var dirty: bool = false ## The last OWN (see NetWorld.decode_own), or empty. var own: Dictionary = {} ## Counts, for tests and the network graph. var applied: int = 0 var gaps: int = 0 var confirmed: int = 0 var rolled_back: int = 0 ## Piece ID -> damage taken, for every piece the server has sent. var _damage: Dictionary = {} ## Piece ID -> the simulation tick its building began, worked back from how far it had ## got when the server sent it. var _build_began: Dictionary = {} ## Provisional pieces: {"id", "slot", "kind", "material", "tick", "owner"}. var _pending: Array[Dictionary] = [] var _next_provisional: int = PROVISIONAL_FIRST_ID var _build_ready_tick: int = 0 var _loot_planned: bool = false ## Starts again on a freshly made world. func begin(fresh: Simulation) -> void: world = fresh seq = -1 tick = 0 dirty = false own = {} _damage.clear() _build_began.clear() _pending.clear() _build_ready_tick = 0 _loot_planned = false ## Applies one decoded WORLD. A full one must be given a world nothing has been applied ## to: see `dirty`. func take(message: Dictionary) -> void: if world == null: return var structures: StructureSet = world.structures if message["full"]: _damage.clear() _build_began.clear() elif int(message["seq"]) != seq + 1: # The channel is reliable and ordered, so this shouldn't happen. Carry on: the # changes are still true. gaps += 1 seq = message["seq"] tick = int(message["tick"]) if message["full"] else maxi(tick, int(message["tick"])) applied += 1 if message["loot"] and not _loot_planned: _loot_planned = true if world.island != null: # The same rolls the server made, from the same stream and the same props. world.loot = LootSet.plan(world.rng.stream("loot"), world.pois.loot_markers(), Simulation.crate_spill_points(world.props)) dirty = true var tide: Dictionary = message["tide"] if not tide.is_empty(): world.tide = Tide.new(tide["started"], tide["levels"]) dirty = true for entry: Array in message["pieces"]: var piece_id: int = entry[NetWorld.P_ID] dirty = true if structures.find(piece_id) == null: _replace_provisional(entry) structures.add(entry[NetWorld.P_KIND], entry[NetWorld.P_MATERIAL], entry[NetWorld.P_SLOT], entry[NetWorld.P_FACING], entry[NetWorld.P_OWNER], entry[NetWorld.P_PLACED], world.ground, piece_id) _damage[piece_id] = entry[NetWorld.P_DAMAGE] _build_began[piece_id] = int(message["tick"]) - int(entry[NetWorld.P_ELAPSED]) _set_progress(piece_id) var damaged: PackedInt32Array = message["damaged"] for index: int in range(0, damaged.size(), 2): if structures.find(damaged[index]) != null: _damage[damaged[index]] = damaged[index + 1] _set_progress(damaged[index]) for piece_id: int in message["removed"]: if structures.remove(piece_id, world.ground): _damage.erase(piece_id) _build_began.erase(piece_id) var props: PackedInt32Array = message["props"] for index: int in range(0, props.size(), 2): var prop: int = props[index] if prop >= world.props.count(): continue dirty = true if world.props.damage(prop, world.props.health[prop] - props[index + 1]): # A broken crate has spilled what it held. world.loot.crate_contents.erase(prop) for chest: int in message["chests"]: if chest < world.loot.chest_opened.size(): world.loot.chest_opened[chest] = 1 dirty = true ## Brings every piece still being built up to simulation tick `sim_tick`. func sync(sim_tick: int) -> void: if world == null: return tick = maxi(tick, sim_tick) for piece_id: int in world.structures.building().duplicate(): _set_progress(piece_id) ## The materials the player has to spend: what the server last said, less what the ## provisional pieces will cost. func available_materials() -> PackedInt32Array: var materials: PackedInt32Array = PackedInt32Array() materials.resize(Materials.NAMES.size()) if not own.is_empty(): materials = (own["materials"] as PackedInt32Array).duplicate() for pending: Dictionary in _pending: var material: int = pending["material"] materials[material] = maxi(materials[material] - StructureSet.cost_of(pending["kind"]), 0) return materials ## Provisional pieces waiting for the server's answer. func pending_count() -> int: return _pending.size() ## The player's command for `command_tick` has just been predicted on `player`: if it ## places a piece and the checks the server will make pass here, puts a provisional ## piece in the world. Returns the Building.Result, or -1 if the command places nothing ## or the last piece was too recent. func try_place(player: SimEntity, command: PlayerCommand, command_tick: int) -> int: if world == null or command == null or command_tick < _build_ready_tick: return -1 if not command.is_pressed(PlayerCommand.BUTTON_BUILD) or not command.is_pressed(PlayerCommand.BUTTON_FIRE): return -1 player.materials = available_materials() var at: Building.Target = Building.target(player, command.selection) var result: Building.Result = Building.check(world, player, at, command.material) if result == Building.Result.OK and Building.would_trap(player, Building.boxes_for_target(at, world.ground)): result = Building.Result.BLOCKED_BY_PLAYER if result != Building.Result.OK: return result var piece: StructureSet.Piece = world.structures.add(at.kind, command.material, at.slot, at.facing, player.id, command_tick, world.ground, _next_provisional) _next_provisional += 1 _pending.append({"id": piece.id, "slot": at.slot, "kind": at.kind, "material": command.material, "tick": command_tick, "owner": player.id}) dirty = true _build_ready_tick = command_tick + Tuning.BUILD_INTERVAL_TICKS Building.lift(player, piece.boxes) player.materials = available_materials() return result ## Called with each snapshot: `sim_tick` is the snapshot's simulation tick and ## `world_seq` the newest WORLD the server had made by then. Takes away every ## provisional piece the server has had its chance to place and didn't. Returns how ## many went. func settle(sim_tick: int, world_seq: int) -> int: if _pending.is_empty() or seq < world_seq: return 0 var waiting: Array[Dictionary] = [] var gone: int = 0 for pending: Dictionary in _pending: if int(pending["tick"]) >= sim_tick: waiting.append(pending) continue world.structures.remove(pending["id"], world.ground) gone += 1 _pending = waiting rolled_back += gone return gone ## The server's piece `entry` is about to be added: a provisional piece in its slot ## makes way. func _replace_provisional(entry: Array) -> void: for index: int in _pending.size(): var pending: Dictionary = _pending[index] if pending["slot"] != entry[NetWorld.P_SLOT]: continue world.structures.remove(pending["id"], world.ground) _pending.remove_at(index) if pending["kind"] == entry[NetWorld.P_KIND] and pending["owner"] == entry[NetWorld.P_OWNER]: confirmed += 1 else: rolled_back += 1 return func _set_progress(piece_id: int) -> void: var piece: StructureSet.Piece = world.structures.find(piece_id) if piece != null: # A provisional piece hasn't begun, as far as the server has said. world.structures.set_progress(piece_id, tick - int(_build_began.get(piece_id, tick)), int(_damage.get(piece_id, 0)))