Built pieces, props' health, opened chests and the tide's schedule now reach clients as WORLD messages on the reliable channel, and each player is told what they carry as OWN messages. - NetWorld: the WORLD and OWN wire formats, and world_hash(), a digest of everything replicated this way. - WorldSender: one message after each tick in which something changed, the same for everyone, and the whole state for someone joining or a new match. StructureSet and PropSet keep the change lists it reads. - ClientWorld: applies them to the client's world, so pieces and broken props are solid for prediction. A piece's health follows from its building and damage, so building costs nothing on the wire. - Placing ahead of the server: a provisional piece goes up with the command and is replaced by the server's, or taken back once a snapshot shows the server had its chance. Snapshots carry the newest WORLD number for that. - Protocol version 3. A test plays a whole scripted match on a real island with a ClientGame attached and compares the two worlds' hashes throughout. Closes #36 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
205 lines
8.0 KiB
GDScript
205 lines
8.0 KiB
GDScript
## Server-authoritative placement. In build mode (BUTTON_BUILD held) a command's
|
|
## `selection` is the piece kind and `material` the material code, and fire places.
|
|
## The server works out the slot from its own copy of the player's position and look,
|
|
## with target(), the same function the client's ghost uses. check() then validates the
|
|
## slot as if a hostile client had chosen it.
|
|
##
|
|
## Targeting: the look direction is snapped to a quarter turn. Walls and breakwaters go
|
|
## on the edge of the builder's own cell in that direction. Floors, ramps and roofs go
|
|
## in the next cell that way, or in the builder's own cell when looking well down. Ramps
|
|
## rise away from the builder. The level is the one nearest the feet, plus a whole cell
|
|
## (two levels) when looking well up.
|
|
class_name Building
|
|
extends RefCounted
|
|
|
|
enum Result {
|
|
OK,
|
|
## Dead, swimming, aboard the barge or falling.
|
|
NOT_ALLOWED,
|
|
## Unknown piece kind or material.
|
|
BAD_REQUEST,
|
|
OUT_OF_WORLD,
|
|
OUT_OF_RANGE,
|
|
OCCUPIED,
|
|
## Would trap a player inside it.
|
|
BLOCKED_BY_PLAYER,
|
|
UNAFFORDABLE,
|
|
## Touches neither the terrain, a fixed solid nor another piece.
|
|
UNSUPPORTED,
|
|
}
|
|
|
|
|
|
## Where a piece would go.
|
|
class Target:
|
|
extends RefCounted
|
|
var kind: int = 0
|
|
var slot: Vector4i = Vector4i.ZERO
|
|
var facing: int = 0
|
|
|
|
|
|
static func is_allowed(player: SimEntity) -> bool:
|
|
return player.health > 0 and player.drop_state == Drop.NONE and not player.swimming
|
|
|
|
|
|
## Quarter-turn facing (0 +z, 1 +x, 2 -z, 3 -x) nearest the player's yaw.
|
|
static func facing_of(player: SimEntity) -> int:
|
|
return posmod(roundi(float(player.yaw) / PlayerCommand.YAW_STEPS * 4.0), 4)
|
|
|
|
|
|
## The slot a piece of `kind` would go in from the player's current pose, or null for
|
|
## an unknown kind.
|
|
static func target(player: SimEntity, kind: int) -> Target:
|
|
if kind < 0 or kind >= StructureSet.KINDS.size():
|
|
return null
|
|
var g: float = StructureSet.cell_size()
|
|
var facing: int = facing_of(player)
|
|
var direction: Vector2i = StructureSet.FACING_DIRECTIONS[facing]
|
|
var pitch_degrees: float = float(player.pitch) / PlayerCommand.PITCH_MAX * 90.0
|
|
var feet: Vector3 = player.position
|
|
var cell: Vector2i = Vector2i(floori(feet.x / g), floori(feet.z / g))
|
|
var level: int = roundi(feet.y / Tuning.BUILD_LEVEL_METRES)
|
|
if pitch_degrees > Tuning.BUILD_LOOK_UP_DEGREES:
|
|
level += roundi(g / Tuning.BUILD_LEVEL_METRES)
|
|
var result: Target = Target.new()
|
|
result.kind = kind
|
|
result.facing = facing
|
|
if StructureSet.is_wall_kind(kind):
|
|
match facing:
|
|
0:
|
|
result.slot = Vector4i(cell.x, level, cell.y + 1, StructureSet.SLOT_WALL_Z)
|
|
1:
|
|
result.slot = Vector4i(cell.x + 1, level, cell.y, StructureSet.SLOT_WALL_X)
|
|
2:
|
|
result.slot = Vector4i(cell.x, level, cell.y, StructureSet.SLOT_WALL_Z)
|
|
_:
|
|
result.slot = Vector4i(cell.x, level, cell.y, StructureSet.SLOT_WALL_X)
|
|
# A wall's facing only records which side the builder stood on.
|
|
return result
|
|
var looking_down: bool = pitch_degrees < -Tuning.BUILD_LOOK_DOWN_DEGREES
|
|
if not looking_down:
|
|
cell += direction
|
|
result.slot = Vector4i(cell.x, level, cell.y, StructureSet.slot_type_of(kind))
|
|
return result
|
|
|
|
|
|
## The boxes the piece would have, skirt included, as placed in `ground`.
|
|
static func boxes_for_target(at: Target, ground: SimGround) -> Array[AABB]:
|
|
var boxes: Array[AABB] = StructureSet.boxes_for(at.kind, at.slot, at.facing)
|
|
if StructureSet.is_wall_kind(at.kind):
|
|
var skirt: AABB = StructureSet.skirt_for(at.kind, boxes[0], ground)
|
|
if skirt.size != Vector3.ZERO:
|
|
boxes.append(skirt)
|
|
return boxes
|
|
|
|
|
|
## Whether `player` may place a piece of `at.kind` in `material` at `at`. Checks
|
|
## everything, as if a hostile client had picked the slot.
|
|
static func check(sim: Simulation, player: SimEntity, at: Target, material: int) -> Result:
|
|
if not is_allowed(player):
|
|
return Result.NOT_ALLOWED
|
|
if at == null or at.kind < 0 or at.kind >= StructureSet.KINDS.size() or not Materials.is_valid(material):
|
|
return Result.BAD_REQUEST
|
|
if at.facing < 0 or at.facing > 3 or at.slot.w != _expected_slot_type(at):
|
|
return Result.BAD_REQUEST
|
|
var boxes: Array[AABB] = boxes_for_target(at, sim.ground)
|
|
if not _inside_world(at, boxes[0]):
|
|
return Result.OUT_OF_WORLD
|
|
var centre: Vector3 = boxes[0].get_center()
|
|
if at.kind == StructureSet.RAMP:
|
|
var whole: AABB = boxes[0]
|
|
for box: AABB in boxes:
|
|
whole = whole.merge(box)
|
|
centre = whole.get_center()
|
|
if Harvest.eye(player).distance_to(centre) > Tuning.BUILD_RANGE:
|
|
return Result.OUT_OF_RANGE
|
|
if sim.structures.occupied(at.slot):
|
|
return Result.OCCUPIED
|
|
if _traps_a_player(sim, boxes):
|
|
return Result.BLOCKED_BY_PLAYER
|
|
if player.materials[material] < StructureSet.cost_of(at.kind):
|
|
return Result.UNAFFORDABLE
|
|
if not sim.structures.touches_fixed_ground(boxes, sim.ground) and sim.structures.touching(boxes, sim.ground).is_empty():
|
|
return Result.UNSUPPORTED
|
|
return Result.OK
|
|
|
|
|
|
## Validates and places. Returns the result; on OK the piece is in `sim.structures`, its
|
|
## cost is spent, players standing in a low step of it are lifted onto it, and a
|
|
## "piece_placed" event is recorded.
|
|
static func place(sim: Simulation, player: SimEntity, at: Target, material: int) -> Result:
|
|
var result: Result = check(sim, player, at, material)
|
|
if result != Result.OK:
|
|
return result
|
|
Materials.spend(player, material, StructureSet.cost_of(at.kind))
|
|
var piece: StructureSet.Piece = sim.structures.add(at.kind, material, at.slot, at.facing, player.id, sim.tick, sim.ground)
|
|
_lift_players(sim, piece.boxes)
|
|
sim.events.append({"type": "piece_placed", "player": player.id, "piece": piece.id, "kind": at.kind, "material": material})
|
|
return result
|
|
|
|
|
|
## A tick of build mode: fire places at the target if the cooldown allows.
|
|
static func act(sim: Simulation, player: SimEntity, command: PlayerCommand) -> void:
|
|
if player.action_cooldown > 0 or not command.is_pressed(PlayerCommand.BUTTON_FIRE):
|
|
return
|
|
var at: Target = target(player, command.selection)
|
|
if place(sim, player, at, command.material) == Result.OK:
|
|
player.action_cooldown = Tuning.BUILD_INTERVAL_TICKS
|
|
|
|
|
|
static func _expected_slot_type(at: Target) -> int:
|
|
if StructureSet.is_wall_kind(at.kind):
|
|
return at.slot.w if at.slot.w == StructureSet.SLOT_WALL_X or at.slot.w == StructureSet.SLOT_WALL_Z else -1
|
|
return StructureSet.slot_type_of(at.kind)
|
|
|
|
|
|
static func _inside_world(at: Target, box: AABB) -> bool:
|
|
if at.slot.y < Tuning.BUILD_MIN_LEVEL or at.slot.y > Tuning.BUILD_MAX_LEVEL:
|
|
return false
|
|
var size: float = Tuning.WORLD_SIZE_METRES
|
|
var slack: float = Tuning.BREAKWATER_THICKNESS
|
|
return box.position.x >= -slack and box.position.z >= -slack and box.end.x <= size + slack and box.end.z <= size + slack
|
|
|
|
|
|
## True if any player's body overlaps the boxes by more than a step.
|
|
static func _traps_a_player(sim: Simulation, boxes: Array[AABB]) -> bool:
|
|
for entity: SimEntity in sim.entities.entities():
|
|
if entity.archetype != SimEntity.ARCHETYPE_PLAYER or entity.health <= 0:
|
|
continue
|
|
if would_trap(entity, boxes):
|
|
return true
|
|
return false
|
|
|
|
|
|
## True if `player`'s body overlaps the boxes by more than a step.
|
|
static func would_trap(player: SimEntity, boxes: Array[AABB]) -> bool:
|
|
var feet: Vector3 = player.position
|
|
var height: float = Movement.body_height(player)
|
|
for box: AABB in boxes:
|
|
if not _body_overlaps(box, feet, height):
|
|
continue
|
|
if box.end.y - feet.y > Tuning.STEP_HEIGHT:
|
|
return true
|
|
return false
|
|
|
|
|
|
static func _lift_players(sim: Simulation, boxes: Array[AABB]) -> void:
|
|
for entity: SimEntity in sim.entities.entities():
|
|
if entity.archetype == SimEntity.ARCHETYPE_PLAYER:
|
|
lift(entity, boxes)
|
|
|
|
|
|
## Lifts `player` onto any low step of the boxes it is standing in.
|
|
static func lift(player: SimEntity, boxes: Array[AABB]) -> void:
|
|
var feet: Vector3 = player.position
|
|
var height: float = Movement.body_height(player)
|
|
for box: AABB in boxes:
|
|
if _body_overlaps(box, feet, height) and box.end.y > player.position.y:
|
|
player.position.y = box.end.y
|
|
|
|
|
|
static func _body_overlaps(box: AABB, feet: Vector3, height: float) -> bool:
|
|
var r: float = Tuning.PLAYER_RADIUS
|
|
if box.end.y <= feet.y or box.position.y >= feet.y + height:
|
|
return false
|
|
return feet.x > box.position.x - r and feet.x < box.end.x + r and feet.z > box.position.z - r and feet.z < box.end.z + r
|