Pieces build up health, take damage from the boathook and the tide, and collapse when nothing connects them to the ground. - Build-up: a piece starts at 10% of its material's health and gains the rest evenly over build_seconds. Damage taken while building stays. - Damage: Simulation.damage_piece, and boathook swings now hit pieces nearer than any prop for HARVEST_DAMAGE, with no material back. - Tide: once a second, pieces with their base under the sea lose TIDE_STRUCTURE_DPS; breakwaters wear per metre of head and fail past BREAKWATER_MAX_HEAD. - Integrity: grounded means touching terrain or a fixed solid (not a prop). On removal, a breadth-first search from the former neighbours stops at the first grounded piece, so only structures that really lost support are walked in full; loose components collapse together. Simulation.ground_changed rechecks grounding after terrain changes. - Wall skirts now reach at most one level (2 m), so upper walls aren't grounded through a skirt; terrain checks merge boxes sharing a bottom. - 12 tests: build-up per material, damage during building, material strength, fresh pieces breaking, cascades, a second support, boathook bringing down a wall and its floor, tide wear and breakwater failure, tide-triggered collapse, terrain-triggered collapse, fixed solids as ground, and a 564-piece fort (one removal 57 us, worst search 416 us, full cascade of 479 pieces 4.7 ms). Closes #17 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
194 lines
7.7 KiB
GDScript
194 lines
7.7 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
|
|
var feet: Vector3 = entity.position
|
|
var height: float = Movement.body_height(entity)
|
|
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:
|
|
continue
|
|
var feet: Vector3 = entity.position
|
|
var height: float = Movement.body_height(entity)
|
|
for box: AABB in boxes:
|
|
if _body_overlaps(box, feet, height) and box.end.y > entity.position.y:
|
|
entity.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
|