67bf85523d
- Rabbits, deer and boars with procedural meshes and animated legs, a state machine (idle/wander/flee/charge/dead) and heightmap steering that avoids water, cliffs, the world edge, trees and buildings - Spawner keeps a habitat-based budget around the player (6/4/3) - Melee needs a weapon or tool (club, spear, axe, pickaxe); box sweep hits - Wooden spear (thrust or throw) and crude bow with draw-scaled arrows; projectiles stick in the world as saved pickups - Carcasses: E to butcher for meat, hide and embedded arrows - Boars charge and gore when hit; hurt flash and a brief healing pause - Cooked meat gives Well fed (faster stamina and healing); buffs saved - Hide cloak: wear for warmth, saved, goes in the grave on death - Feathers as meadow pickups (appended, existing save ids unchanged) - New test_creatures_combat suite; run_all.sh gets a per-suite time limit
767 lines
30 KiB
GDScript
767 lines
30 KiB
GDScript
extends Node3D
|
|
## World controller.
|
|
##
|
|
## Owns spawn ordering so the player never falls through ungenerated ground:
|
|
## waits for the terrain, places the scenery, then drops the player onto a dry,
|
|
## flat spot facing the lake. Also aims the sun, and respawns the player if they
|
|
## somehow leave the map or fall below it (a safety net behind the mountain rim
|
|
## and invisible wall in terrain.gd).
|
|
##
|
|
## Dev hook: `godot --path . -- --shot=/abs/prefix` renders a few fixed views to
|
|
## <prefix>_<view>.png and quits. Handy for checking visual changes.
|
|
|
|
|
|
@onready var terrain: Node3D = $Terrain
|
|
@onready var props: Node3D = $Props
|
|
@onready var player: CharacterBody3D = $Player
|
|
@onready var sun: DirectionalLight3D = $Sun
|
|
|
|
const PIECES := {
|
|
"campfire": preload("res://scripts/building/campfire.gd"),
|
|
"workbench": preload("res://scripts/building/workbench.gd"),
|
|
"chest": preload("res://scripts/building/chest.gd"),
|
|
"grave": preload("res://scripts/building/grave.gd"),
|
|
"build": preload("res://scripts/building/build_piece.gd"),
|
|
"door": preload("res://scripts/building/door.gd"),
|
|
"bed": preload("res://scripts/building/bed.gd"),
|
|
}
|
|
const BuildPiece = preload("res://scripts/building/build_piece.gd")
|
|
|
|
const AUTOSAVE_SECONDS := 120.0
|
|
|
|
## Set by the title screen before adding the world: no player, no HUD, no
|
|
## saving, just a slow camera flight over the island as a menu backdrop.
|
|
var menu_mode := false
|
|
|
|
var _spawn := Vector3.ZERO
|
|
var _spawn_yaw := 0.0
|
|
var _pieces: Node3D
|
|
var hud: CanvasLayer
|
|
var _session_time := 0.0 ## seconds played since the last save
|
|
var _autosave_left := AUTOSAVE_SECONDS
|
|
var _menu_cam: Camera3D
|
|
var _menu_t := 0.0
|
|
var day_night: Node ## day_night.gd: time of day, sun, sky
|
|
var weather: Node ## weather.gd: the weather model
|
|
var weather_fx: Node3D ## weather_fx.gd: rain/snow particles, sound
|
|
var build: Node ## build_system.gd: snapping, support, shelter
|
|
var creatures: Node3D ## spawner.gd: wildlife around the player
|
|
var _dropped: Node3D ## arrows, spears and other dropped items
|
|
var has_bed_spawn := false
|
|
var bed_spawn := Vector3.ZERO ## position of the bed you respawn at
|
|
var _loading := false ## applying a save: defer support recompute
|
|
|
|
func _ready() -> void:
|
|
_pieces = Node3D.new()
|
|
_pieces.name = "Pieces"
|
|
add_child(_pieces)
|
|
day_night = preload("res://scripts/world/day_night.gd").new()
|
|
day_night.name = "DayNight"
|
|
add_child(day_night)
|
|
day_night.setup(sun, $WorldEnvironment.environment)
|
|
weather = preload("res://scripts/world/weather.gd").new()
|
|
weather.name = "Weather"
|
|
add_child(weather)
|
|
weather.snowline = terrain.snow_height - 8.0
|
|
weather.frozen = menu_mode
|
|
weather.setup(terrain.noise_seed, day_night)
|
|
day_night.weather = weather
|
|
build = preload("res://scripts/building/build_system.gd").new()
|
|
build.name = "Build"
|
|
add_child(build)
|
|
build.setup(self)
|
|
_dropped = Node3D.new()
|
|
_dropped.name = "Dropped"
|
|
add_child(_dropped)
|
|
creatures = preload("res://scripts/creatures/spawner.gd").new()
|
|
creatures.name = "Creatures"
|
|
creatures.enabled = false # until the scenery is placed
|
|
add_child(creatures)
|
|
if not menu_mode and DisplayServer.get_name() != "headless":
|
|
weather_fx = preload("res://scripts/world/weather_fx.gd").new()
|
|
weather_fx.name = "WeatherFX"
|
|
add_child(weather_fx)
|
|
weather_fx.setup(weather, player)
|
|
if menu_mode:
|
|
day_night.time = 9.5 / 24.0
|
|
day_night.frozen = true
|
|
day_night.apply(true)
|
|
player.process_mode = Node.PROCESS_MODE_DISABLED
|
|
player.get_node("Camera3D").current = false
|
|
_menu_cam = Camera3D.new()
|
|
add_child(_menu_cam)
|
|
_menu_cam.current = true
|
|
$HUD.visible = false
|
|
elif DisplayServer.get_name() != "headless":
|
|
hud = preload("res://scripts/ui/hud.gd").new()
|
|
add_child(hud)
|
|
hud.bind(player)
|
|
if not menu_mode:
|
|
player.survival.died.connect(_on_player_died)
|
|
if Saves.has_world() and not menu_mode:
|
|
# Save on window close instead of quitting straight away.
|
|
get_tree().auto_accept_quit = false
|
|
player.set_physics_process(false)
|
|
set_physics_process(false)
|
|
if terrain.built:
|
|
_on_terrain_ready()
|
|
else:
|
|
terrain.ready_built.connect(_on_terrain_ready)
|
|
|
|
# --- survival environment ---------------------------------------------------
|
|
|
|
## 0..100 air warmth at `pos` before fires: time of day, minus altitude,
|
|
## plus the weather. A proper shelter keeps out most of the weather and adds a
|
|
## little warmth of its own.
|
|
func air_warmth(pos: Vector3, sheltered: bool = false) -> float:
|
|
var w: float = day_night.air_warmth()
|
|
w -= maxf(pos.y - 12.0, 0.0) * 0.9
|
|
var ww: float = weather.warmth_at(pos)
|
|
if sheltered:
|
|
w += ww * 0.25 + 8.0
|
|
else:
|
|
w += ww
|
|
return w
|
|
|
|
## 0..1 heat from fires and a held torch.
|
|
func heat_at(pos: Vector3) -> float:
|
|
var h := 0.0
|
|
for n in get_tree().get_nodes_in_group("heat"):
|
|
h = maxf(h, n.heat_at(pos))
|
|
if player.hands != null:
|
|
h = maxf(h, player.hands.held_heat())
|
|
return h
|
|
|
|
## Death: everything you carried goes into a grave where you fell, and you
|
|
## wake up at the island start. The world carries on.
|
|
func _on_player_died() -> void:
|
|
var pos := player.global_position
|
|
pos.y = terrain.sample_height(pos.x, pos.z)
|
|
if pos.y < terrain.water_level:
|
|
# Drowned or died in the lake: put the grave on the nearest dry shore.
|
|
pos = terrain.find_spawn(Vector2(pos.x, pos.z))
|
|
# What you were wearing goes in the grave too.
|
|
if not player.worn.is_empty() and player.inventory.add(player.worn, 1) == 0:
|
|
player.worn = ""
|
|
player.worn_changed.emit()
|
|
var has_items := false
|
|
for st in player.inventory.slots:
|
|
if st != null:
|
|
has_items = true
|
|
if has_items:
|
|
var grave := spawn_piece(ItemDB.get_item("grave"), Transform3D(Basis(Vector3.UP, player.rotation.y), pos))
|
|
grave.inventory.load_data(player.inventory.to_data())
|
|
player.inventory.load_data(Inventory.new(player.inventory.size()).to_data())
|
|
if hud != null:
|
|
hud.close_screens()
|
|
var bed := spawn_bed()
|
|
if bed != null:
|
|
_respawn_at_bed(bed)
|
|
else:
|
|
_respawn()
|
|
if has_bed_spawn:
|
|
has_bed_spawn = false
|
|
Actions.notify.emit("Your bed is gone, so you woke at the island start")
|
|
player.survival.reset_after_death()
|
|
Actions.notify.emit("You died. Your belongings are in your grave." if has_items else "You died.")
|
|
|
|
# --- beds and sleeping ------------------------------------------------------
|
|
|
|
## The bed you respawn at, if it still exists.
|
|
func spawn_bed() -> Node3D:
|
|
if not has_bed_spawn:
|
|
return null
|
|
for p in _pieces.get_children():
|
|
if p.item_id == "bed" and not p.is_queued_for_deletion() and p.global_position.distance_to(bed_spawn) < 0.3:
|
|
return p
|
|
return null
|
|
|
|
func set_bed_spawn(bed: Node3D) -> void:
|
|
has_bed_spawn = true
|
|
bed_spawn = bed.global_position
|
|
|
|
func _respawn_at_bed(bed: Node3D) -> void:
|
|
player.global_position = bed.global_position + Vector3(0, 0.9, 0)
|
|
player.velocity = Vector3.ZERO
|
|
player.rotation = Vector3(0.0, bed.global_basis.get_euler().y + PI, 0.0)
|
|
player.get_node("Camera3D").rotation.x = 0.0
|
|
|
|
## Why you can't sleep in `bed` right now ("" = you can).
|
|
func sleep_block_reason(bed: Node3D) -> String:
|
|
var h: float = day_night.hours()
|
|
if h > 5.5 and h < 19.5:
|
|
return "You can only sleep at night (after 19:30)"
|
|
if not build.sheltered_at(bed.global_position):
|
|
return "Your bed needs a roof and walls around it"
|
|
return ""
|
|
|
|
## Sleeps until 06:00: the clock, fires, regrowth and weather all move on.
|
|
func sleep(p: Node3D) -> void:
|
|
var secs: float = fposmod(6.0 - day_night.hours(), 24.0) / 24.0 * day_night.day_length
|
|
if hud != null:
|
|
hud.fade(func(): _finish_sleep(p, secs))
|
|
else:
|
|
_finish_sleep(p, secs)
|
|
|
|
func _finish_sleep(p: Node3D, secs: float) -> void:
|
|
skip_time(secs)
|
|
p.survival.after_sleep(secs)
|
|
save_now()
|
|
Actions.notify.emit("You slept until morning")
|
|
|
|
## Fast-forwards the world (not the player) by `secs`.
|
|
func skip_time(secs: float) -> void:
|
|
day_night.advance(secs)
|
|
day_night.apply(true)
|
|
weather.snap()
|
|
props.skip_time(secs)
|
|
for f in get_tree().get_nodes_in_group("heat"):
|
|
if f.has_method("burn"):
|
|
f.burn(secs)
|
|
|
|
func _on_terrain_ready() -> void:
|
|
var t0 := Time.get_ticks_msec()
|
|
_spawn = terrain.find_spawn(Vector2.ZERO)
|
|
var lake: Vector2 = terrain.lake_center
|
|
var to_lake := lake - Vector2(_spawn.x, _spawn.z)
|
|
_spawn_yaw = atan2(-to_lake.x, -to_lake.y)
|
|
player.water_level = terrain.water_level
|
|
props.place_on(terrain, player if not menu_mode else _menu_cam, _spawn)
|
|
print("[world] scenery placed in %d ms" % (Time.get_ticks_msec() - t0))
|
|
if menu_mode:
|
|
return
|
|
_respawn()
|
|
if Saves.has_world():
|
|
var state: Dictionary = Saves.load_state(Saves.current_id)
|
|
if not state.is_empty():
|
|
apply_save(state)
|
|
print("[world] loaded '%s'" % Saves.current_id)
|
|
player.set_physics_process(true)
|
|
set_physics_process(true)
|
|
creatures.setup(self)
|
|
if not "--no-creatures" in OS.get_cmdline_user_args():
|
|
creatures.populate()
|
|
creatures.enabled = true
|
|
_maybe_capture()
|
|
|
|
func _process(delta: float) -> void:
|
|
if menu_mode:
|
|
# Slow orbit over the valley, looking toward the lake.
|
|
_menu_t += delta * 0.025
|
|
var r := 70.0
|
|
var p := Vector3(cos(_menu_t) * r, 0.0, sin(_menu_t) * r)
|
|
p.y = maxf(terrain.sample_height(p.x, p.z), terrain.water_level) + 24.0
|
|
_menu_cam.global_position = p
|
|
var lake: Vector2 = terrain.lake_center
|
|
_menu_cam.look_at(Vector3(lake.x * 0.5, 2.0, lake.y * 0.5), Vector3.UP)
|
|
return
|
|
if not Saves.has_world() or get_tree().paused:
|
|
return
|
|
_session_time += delta
|
|
_autosave_left -= delta
|
|
if _autosave_left <= 0.0:
|
|
save_now()
|
|
|
|
# --- saving -----------------------------------------------------------------
|
|
|
|
## Writes the current game to the active world slot. Returns false if this
|
|
## session isn't tied to a slot (e.g. running world.tscn directly).
|
|
func save_now() -> bool:
|
|
_autosave_left = AUTOSAVE_SECONDS
|
|
if not Saves.has_world():
|
|
return false
|
|
var ok: bool = Saves.save_state(Saves.current_id, collect_save(), _session_time)
|
|
if ok:
|
|
_session_time = 0.0
|
|
Actions.notify.emit("Game saved" if ok else "Save FAILED")
|
|
return ok
|
|
|
|
func _notification(what: int) -> void:
|
|
if what == NOTIFICATION_WM_CLOSE_REQUEST and Saves.has_world() and not menu_mode:
|
|
save_now()
|
|
get_tree().quit()
|
|
|
|
static func _xf_to_array(xf: Transform3D) -> Array:
|
|
var b := xf.basis
|
|
return [b.x.x, b.x.y, b.x.z, b.y.x, b.y.y, b.y.z, b.z.x, b.z.y, b.z.z, xf.origin.x, xf.origin.y, xf.origin.z]
|
|
|
|
static func _array_to_xf(a: Array) -> Transform3D:
|
|
return Transform3D(Vector3(a[0], a[1], a[2]), Vector3(a[3], a[4], a[5]), Vector3(a[6], a[7], a[8]), Vector3(a[9], a[10], a[11]))
|
|
|
|
## Everything the player changed. The rest regenerates from the seed.
|
|
func collect_save() -> Dictionary:
|
|
var cam: Camera3D = player.get_node("Camera3D")
|
|
var harvested := {}
|
|
for uid in props.resource_nodes:
|
|
var n = props.resource_nodes[uid]
|
|
if not is_instance_valid(n) or n.depleted:
|
|
harvested[uid] = 0.0
|
|
elif n.hp < n.max_hp:
|
|
harvested[uid] = n.hp
|
|
var regrow := {}
|
|
for uid in props.forage:
|
|
var f = props.forage[uid]
|
|
if is_instance_valid(f) and f.regrow_left > 0.0:
|
|
regrow[uid] = f.regrow_left
|
|
var taken: Array = []
|
|
for uid in props.pickups:
|
|
var pk = props.pickups[uid]
|
|
if not is_instance_valid(pk) or pk.taken:
|
|
taken.append(uid)
|
|
var dropped: Array = []
|
|
for d in _dropped.get_children():
|
|
if d.is_queued_for_deletion() or d.taken:
|
|
continue
|
|
dropped.append({"item": d.item_id, "count": d.amount, "xf": _xf_to_array(d.global_transform)})
|
|
var pieces: Array = []
|
|
for piece in _pieces.get_children():
|
|
if piece.is_queued_for_deletion():
|
|
continue
|
|
var entry := {"item": piece.item_id, "xf": _xf_to_array(piece.global_transform)}
|
|
if piece.get("inventory") != null:
|
|
entry["inventory"] = piece.inventory.to_data()
|
|
if piece.has_method("save_extra"):
|
|
entry["extra"] = piece.save_extra()
|
|
pieces.append(entry)
|
|
return {
|
|
"player": {
|
|
"pos": [player.global_position.x, player.global_position.y, player.global_position.z],
|
|
"yaw": player.rotation.y,
|
|
"pitch": cam.rotation.x,
|
|
"inventory": player.inventory.to_data(),
|
|
"selected": player.selected,
|
|
"stats": player.survival.to_data(),
|
|
"worn": player.worn,
|
|
},
|
|
"dropped": dropped,
|
|
"time": {"day": day_night.day, "time": day_night.time},
|
|
"spawn": {"bed": has_bed_spawn, "pos": [bed_spawn.x, bed_spawn.y, bed_spawn.z]},
|
|
"forage_regrow": regrow,
|
|
"regrow": props.regrow.duplicate(),
|
|
"harvested": harvested,
|
|
"pickups_taken": taken,
|
|
"pieces": pieces,
|
|
}
|
|
|
|
func apply_save(s: Dictionary) -> void:
|
|
var p: Dictionary = s.get("player", {})
|
|
if p.has("pos"):
|
|
player.global_position = Vector3(p.pos[0], p.pos[1] + 0.05, p.pos[2])
|
|
player.rotation = Vector3(0.0, float(p.get("yaw", 0.0)), 0.0)
|
|
player.get_node("Camera3D").rotation.x = float(p.get("pitch", 0.0))
|
|
if p.has("inventory"):
|
|
player.inventory.load_data(p.inventory)
|
|
player.select(int(p.get("selected", 0)))
|
|
if p.has("stats"):
|
|
player.survival.load_data(p.stats)
|
|
player.worn = String(p.get("worn", ""))
|
|
player.worn_changed.emit()
|
|
for d in s.get("dropped", []):
|
|
if not ItemDB.get_item(d.get("item", "")).is_empty():
|
|
drop_item(d.item, int(d.get("count", 1)), _array_to_xf(d.xf))
|
|
var t: Dictionary = s.get("time", {})
|
|
if not t.is_empty():
|
|
day_night.day = int(t.get("day", 1))
|
|
day_night.time = float(t.get("time", day_night.time))
|
|
day_night.apply(true)
|
|
var regrow: Dictionary = s.get("forage_regrow", {})
|
|
for uid in regrow:
|
|
if props.forage.has(uid):
|
|
props.forage[uid].restore(float(regrow[uid]))
|
|
var harvested: Dictionary = s.get("harvested", {})
|
|
for uid in harvested:
|
|
if props.resource_nodes.has(uid):
|
|
props.resource_nodes[uid].restore(float(harvested[uid]))
|
|
for uid in s.get("pickups_taken", []):
|
|
if props.pickups.has(uid) and is_instance_valid(props.pickups[uid]):
|
|
props.pickups[uid].collected()
|
|
# Regrowth timers (older saves have none: everything gone starts a fresh timer).
|
|
props.restore_regrow(s.get("regrow", {}))
|
|
var sp: Dictionary = s.get("spawn", {})
|
|
has_bed_spawn = bool(sp.get("bed", false))
|
|
if sp.has("pos"):
|
|
bed_spawn = Vector3(sp.pos[0], sp.pos[1], sp.pos[2])
|
|
weather.snap()
|
|
_loading = true
|
|
for e in s.get("pieces", []):
|
|
var def: Dictionary = ItemDB.get_item(e.get("item", ""))
|
|
if def.is_empty() or not def.has("place"):
|
|
continue
|
|
var piece := spawn_piece(def, _array_to_xf(e.xf))
|
|
if e.has("inventory") and piece.get("inventory") != null:
|
|
piece.inventory.load_data(e.inventory)
|
|
if e.has("extra") and piece.has_method("load_extra"):
|
|
piece.load_extra(e.extra)
|
|
_loading = false
|
|
build.recompute() # same terrain, same pieces: nothing collapses on load
|
|
_update_grass_cuts()
|
|
|
|
func _respawn() -> void:
|
|
player.global_position = _spawn + Vector3(0.0, 1.5, 0.0)
|
|
player.velocity = Vector3.ZERO
|
|
player.rotation = Vector3(0.0, _spawn_yaw, 0.0)
|
|
player.get_node("Camera3D").rotation.x = 0.0
|
|
|
|
func _physics_process(_delta: float) -> void:
|
|
var p := player.global_position
|
|
var half: float = terrain.size * 0.5
|
|
if p.y < terrain.min_height - 30.0 or absf(p.x) > half or absf(p.z) > half \
|
|
or not terrain.inside_boundary(p.x, p.z, -4.0):
|
|
push_warning("[world] player left the map at %s; respawning" % p)
|
|
_respawn()
|
|
|
|
# --- building ---------------------------------------------------------------
|
|
|
|
## Whether a piece can go at `xf`: inside the valley, on dry fairly flat
|
|
## ground (or a floor), and not overlapping trees, rocks or other pieces.
|
|
## Building pieces have their own rules (build_system.gd).
|
|
func placement_valid(def: Dictionary, xf: Transform3D) -> bool:
|
|
if BuildPiece.is_build(def):
|
|
return build.check(def, xf).is_empty()
|
|
var p := xf.origin
|
|
if not terrain.inside_boundary(p.x, p.z, 1.5):
|
|
return false
|
|
if p.y < terrain.water_level + 0.15:
|
|
return false
|
|
var fp: Array = def.place.get("footprint", [1.0, 1.0])
|
|
var hx := float(fp[0]) * 0.5
|
|
var hz := float(fp[1]) * 0.5
|
|
# Something solid (ground or a floor) under each corner, close to the base.
|
|
var space := get_world_3d().direct_space_state
|
|
for c in [Vector3(-hx, 0, -hz), Vector3(hx, 0, -hz), Vector3(-hx, 0, hz), Vector3(hx, 0, hz)]:
|
|
var w: Vector3 = xf * c
|
|
var rq := PhysicsRayQueryParameters3D.create(w + Vector3(0, 0.45, 0), w - Vector3(0, 0.45, 0), 1, [player.get_rid()])
|
|
if space.intersect_ray(rq).is_empty():
|
|
return false
|
|
# Overlap test against everything solid except the ground itself.
|
|
var box := BoxShape3D.new()
|
|
box.size = Vector3(hx * 2.0 - 0.1, 1.0, hz * 2.0 - 0.1)
|
|
var q := PhysicsShapeQueryParameters3D.new()
|
|
q.shape = box
|
|
q.transform = Transform3D(xf.basis, p + Vector3(0, 0.75, 0))
|
|
q.collision_mask = 1
|
|
q.exclude = [terrain.get_node("TerrainBody").get_rid(), player.get_rid()]
|
|
return get_world_3d().direct_space_state.intersect_shape(q, 1).is_empty()
|
|
|
|
func spawn_piece(def: Dictionary, xf: Transform3D) -> Node3D:
|
|
var script: Script = PIECES.get(def.place.piece, preload("res://scripts/building/piece.gd"))
|
|
var piece: StaticBody3D = script.new()
|
|
piece.setup(def)
|
|
_pieces.add_child(piece)
|
|
piece.global_transform = xf
|
|
if piece.is_in_group("build") and not _loading:
|
|
build.recompute()
|
|
if piece.kind == "floor":
|
|
_update_grass_cuts()
|
|
return piece
|
|
|
|
## Grass doesn't grow up through floors.
|
|
func _update_grass_cuts() -> void:
|
|
var xfs: Array = []
|
|
for p in _pieces.get_children():
|
|
if p.is_in_group("build") and p.kind == "floor" and not p.is_queued_for_deletion():
|
|
xfs.append(p.global_transform)
|
|
props.set_grass_cuts(xfs, 1.02)
|
|
|
|
## Leaves `count` of an item lying in the world at `xf` (an arrow stuck in a
|
|
## tree, a thrown spear, meat that didn't fit). Saved with the world.
|
|
func drop_item(id: String, count: int, xf: Transform3D) -> Node3D:
|
|
var pk: Area3D = preload("res://scripts/world/pickup.gd").new()
|
|
pk.setup(id, ItemDB.mesh_for(id), ItemDB.item_material(), 0.3)
|
|
pk.amount = count
|
|
pk.dropped = true
|
|
_dropped.add_child(pk)
|
|
pk.global_transform = xf
|
|
return pk
|
|
|
|
## Fires an arrow or thrown spear (Actions validated it).
|
|
func launch(id: String, origin: Vector3, vel: Vector3, damage: float, shooter: Node3D) -> Node3D:
|
|
var pr: Node3D = preload("res://scripts/creatures/projectile.gd").new()
|
|
pr.setup(id, self, origin, vel, damage, shooter)
|
|
add_child(pr)
|
|
return pr
|
|
|
|
## Takes a piece out of the world (dismantled). Anything that loses its
|
|
## support collapses, and its item goes back to `refund_to` if there's room.
|
|
## Returns how many pieces collapsed.
|
|
func remove_piece(piece: Node3D, refund_to: Node3D = null) -> int:
|
|
if piece.item_id == "bed" and spawn_bed() == piece:
|
|
has_bed_spawn = false
|
|
Actions.notify.emit("Spawn point cleared")
|
|
var was_build := piece.is_in_group("build")
|
|
_pieces.remove_child(piece)
|
|
piece.queue_free()
|
|
if not was_build:
|
|
return 0
|
|
var weak: Array = build.recompute()
|
|
for w in weak:
|
|
if refund_to != null:
|
|
Actions._give(refund_to, w.item_id, 1)
|
|
_collapse_fx(w)
|
|
_pieces.remove_child(w)
|
|
w.queue_free()
|
|
if not weak.is_empty():
|
|
build.recompute()
|
|
Actions.notify.emit("%d piece%s collapsed" % [weak.size(), "" if weak.size() == 1 else "s"])
|
|
_settle_loose_pieces()
|
|
_update_grass_cuts()
|
|
return weak.size()
|
|
|
|
## A collapsing piece: a copy of its mesh tumbles down and sinks away.
|
|
func _collapse_fx(piece: Node3D) -> void:
|
|
if DisplayServer.get_name() == "headless":
|
|
return
|
|
var mi := MeshInstance3D.new()
|
|
mi.mesh = piece.get_node("Mesh").mesh
|
|
mi.material_override = ItemDB.item_material()
|
|
add_child(mi)
|
|
mi.global_transform = piece.global_transform
|
|
var tw := mi.create_tween().set_parallel(true)
|
|
tw.tween_property(mi, "global_position:y", mi.global_position.y - 4.0, 1.2).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN)
|
|
tw.tween_property(mi, "rotation:x", mi.rotation.x + randf_range(-0.8, 0.8), 1.2)
|
|
tw.chain().tween_callback(mi.queue_free)
|
|
|
|
## Chests, fires and beds left hanging after a collapse drop to whatever is
|
|
## below them.
|
|
func _settle_loose_pieces() -> void:
|
|
var space := get_world_3d().direct_space_state
|
|
for p in _pieces.get_children():
|
|
if p.is_in_group("build") or p.is_queued_for_deletion():
|
|
continue
|
|
var at: Vector3 = p.global_position
|
|
var rq := PhysicsRayQueryParameters3D.create(at + Vector3(0, 0.3, 0), at - Vector3(0, 0.5, 0), 1, [p.get_rid()])
|
|
if not space.intersect_ray(rq).is_empty():
|
|
continue
|
|
rq = PhysicsRayQueryParameters3D.create(at, at - Vector3(0, 80, 0), 1, [p.get_rid(), player.get_rid()])
|
|
var hit := space.intersect_ray(rq)
|
|
p.global_position.y = hit.position.y if not hit.is_empty() else terrain.sample_height(at.x, at.z)
|
|
|
|
# --- dev screenshot hook ----------------------------------------------------
|
|
|
|
func _maybe_capture() -> void:
|
|
var prefix := ""
|
|
for a in OS.get_cmdline_user_args():
|
|
if a.begins_with("--shot="):
|
|
prefix = a.trim_prefix("--shot=")
|
|
if prefix.is_empty():
|
|
return
|
|
var lake: Vector2 = terrain.lake_center
|
|
# [name, eye position (y = height above ground), look-at point] ; null = spawn view
|
|
var views := [
|
|
["spawn", null, null],
|
|
["aerial", Vector3(0, 110, 150), Vector3(0, 0, -20)],
|
|
["lake", Vector3(lake.x - 30.0, 3.0, lake.y + 22.0), Vector3(lake.x, -2.0, lake.y)],
|
|
["forest", Vector3(-40, 1.7, 30), Vector3(-70, 4.0, 10)],
|
|
["rim", Vector3(0, 2.0, 70), Vector3(0, 25.0, 125)],
|
|
]
|
|
# Sea-cliff views: from the cliff top out to sea, and from the water back at the cliff.
|
|
var sa: float = terrain.sea_angle_deg
|
|
var top: Vector2 = terrain.coast_point(sa + 12.0, -6.0)
|
|
var out: Vector2 = terrain.coast_point(sa + 12.0, 200.0)
|
|
views.append(["seacliff_top", Vector3(top.x, 1.7, top.y), Vector3(out.x, terrain.sea_level - 6.0, out.y)])
|
|
var boat: Vector2 = terrain.coast_point(sa - 6.0, 38.0)
|
|
var face: Vector2 = terrain.coast_point(sa + 4.0, 0.0)
|
|
var boat_eye := Vector3(boat.x, terrain.sea_level + 3.0 - terrain.sample_height(boat.x, boat.y), boat.y)
|
|
views.append(["seacliff_from_sea", boat_eye, Vector3(face.x, terrain.sea_level + 8.0, face.y)])
|
|
# Along the cliff edge into the western headland (where the old pit was).
|
|
var walk: Vector2 = terrain.coast_point(sa - 20.0, -8.0)
|
|
var head: Vector2 = terrain.coast_point(sa - 52.0, 0.0)
|
|
views.append(["headland", Vector3(walk.x, 1.7, walk.y), Vector3(head.x, 2.0, head.y)])
|
|
await get_tree().create_timer(4.0).timeout
|
|
set_physics_process(false) # views may sit outside the walkable area
|
|
var cam: Camera3D = player.get_node("Camera3D")
|
|
for v in views:
|
|
if v[1] != null:
|
|
player.set_physics_process(false)
|
|
var eye: Vector3 = v[1]
|
|
eye.y += terrain.sample_height(eye.x, eye.z)
|
|
var dir: Vector3 = (v[2] as Vector3) - eye
|
|
player.global_position = eye - Vector3(0.0, cam.position.y, 0.0)
|
|
player.rotation = Vector3(0.0, atan2(-dir.x, -dir.z), 0.0)
|
|
cam.rotation.x = atan2(dir.y, Vector2(dir.x, dir.z).length())
|
|
props._update_grass(100000)
|
|
await get_tree().create_timer(1.0).timeout
|
|
await RenderingServer.frame_post_draw
|
|
var path := "%s_%s.png" % [prefix, v[0]]
|
|
get_viewport().get_texture().get_image().save_png(path)
|
|
print("[world] saved ", path)
|
|
await _capture_survival(prefix, cam)
|
|
get_tree().quit()
|
|
|
|
## Survival views: a small camp in front of the spawn (axe in hand), then the
|
|
## inventory screen with a chest open.
|
|
func _capture_survival(prefix: String, cam: Camera3D) -> void:
|
|
_respawn()
|
|
var inv: Inventory = player.inventory
|
|
for pair in [["stone_axe", 1], ["stone_pickaxe", 1], ["campfire", 1], ["club", 1],
|
|
["wood", 23], ["stick", 12], ["stone", 17], ["flint", 5]]:
|
|
inv.add(pair[0], pair[1])
|
|
var fwd := -player.global_basis.z
|
|
var right := player.global_basis.x
|
|
var chest: Node = null
|
|
for k in [["campfire", 4.5, 0.0], ["workbench", 7.0, -2.8], ["chest", 6.5, 2.4]]:
|
|
var p: Vector3 = player.global_position + fwd * float(k[1]) + right * float(k[2])
|
|
p.y = terrain.sample_height(p.x, p.z)
|
|
var piece := spawn_piece(ItemDB.get_item(k[0]), Transform3D(Basis(Vector3.UP, player.rotation.y), p))
|
|
if k[0] == "chest":
|
|
chest = piece
|
|
player.select(0)
|
|
cam.rotation.x = -0.22
|
|
await get_tree().create_timer(2.5).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_camp.png" % prefix)
|
|
print("[world] saved %s_camp.png" % prefix)
|
|
|
|
# Same camp at dusk and at night, torch in hand.
|
|
inv.set_slot(1, {"id": "torch", "count": 1})
|
|
player.select(1)
|
|
for shot in [["dusk", 18.3], ["night", 22.5]]:
|
|
day_night.time = float(shot[1]) / 24.0
|
|
day_night.apply(true)
|
|
await get_tree().create_timer(1.5).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_camp_%s.png" % [prefix, shot[0]])
|
|
print("[world] saved %s_camp_%s.png" % [prefix, shot[0]])
|
|
day_night.time = 9.0 / 24.0
|
|
day_night.apply(true)
|
|
|
|
chest.inventory.add("wood", 40)
|
|
chest.inventory.add("stone", 12)
|
|
player.global_position = chest.global_position + fwd * -2.0
|
|
hud._screen.open(chest)
|
|
await get_tree().create_timer(0.6).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_inventory.png" % prefix)
|
|
print("[world] saved %s_inventory.png" % prefix)
|
|
|
|
hud._screen.close()
|
|
hud._menu.open()
|
|
await get_tree().create_timer(0.4).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_menu.png" % prefix)
|
|
print("[world] saved %s_menu.png" % prefix)
|
|
hud._menu.close()
|
|
await _capture_weather(prefix, cam)
|
|
await _capture_creatures(prefix, cam)
|
|
|
|
## Wildlife views: a rabbit, a deer and a boar in a meadow, the bow drawn on
|
|
## a deer, and a carcass with an arrow in it.
|
|
func _capture_creatures(prefix: String, cam: Camera3D) -> void:
|
|
weather.force("clear")
|
|
weather.snow_cover = 0.0
|
|
weather.ground_wet = 0.0
|
|
day_night.time = 9.5 / 24.0
|
|
day_night.apply(true)
|
|
creatures.enabled = false
|
|
for c in creatures.get_children():
|
|
c.queue_free()
|
|
_respawn()
|
|
player.survival.wet = 0.0
|
|
# Open meadow toward the lake, looking the same way as the spawn view.
|
|
var site: Vector3 = build.debug_find_site(player.global_position - player.global_basis.z * 16.0 + player.global_basis.x * 10.0, 7.0)
|
|
site.y = terrain.sample_height(site.x, site.z)
|
|
var hb := Basis(Vector3.UP, player.rotation.y)
|
|
var line: Array = []
|
|
for k in [["rabbit", Vector3(-1.6, 0, -4.0), 0.9], ["deer", Vector3(1.4, 0, -8.0), -1.2], ["boar", Vector3(-3.8, 0, -7.5), 2.1]]:
|
|
var c: Node3D = creatures.spawn(k[0], site + hb * (k[1] as Vector3))
|
|
c.set_physics_process(false)
|
|
c.yaw = player.rotation.y + float(k[2])
|
|
c.rotation.y = c.yaw
|
|
line.append(c)
|
|
var eye: Vector3 = site + hb * Vector3(0, 0, 1.0)
|
|
eye.y = terrain.sample_height(eye.x, eye.z) + 1.7
|
|
player.set_physics_process(false)
|
|
player.inventory.set_slot(2, {"id": "spear", "count": 1})
|
|
player.select(2)
|
|
_aim_camera(cam, eye, site + hb * Vector3(-0.8, 0.4, -6.0))
|
|
await get_tree().create_timer(1.5).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_animals.png" % prefix)
|
|
print("[world] saved %s_animals.png" % prefix)
|
|
# Bow drawn on the deer.
|
|
player.inventory.set_slot(3, {"id": "bow", "count": 1})
|
|
player.inventory.set_slot(4, {"id": "arrow", "count": 12})
|
|
player.select(3)
|
|
var deer: Node3D = line[1]
|
|
_aim_camera(cam, eye, deer.global_position + Vector3(0, 1.1, 0))
|
|
player.hands._drawing = true
|
|
player.hands._draw_t = 0.8
|
|
await get_tree().create_timer(0.8).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_bow.png" % prefix)
|
|
print("[world] saved %s_bow.png" % prefix)
|
|
player.hands._drawing = false
|
|
# A felled deer.
|
|
deer.take_hit(100.0, eye, "arrow")
|
|
player.select(0)
|
|
var back := eye - deer.global_position
|
|
back.y = 0.0
|
|
var near: Vector3 = deer.global_position + back.normalized() * 2.8
|
|
near.y = terrain.sample_height(near.x, near.z) + 1.7
|
|
_aim_camera(cam, near, deer.global_position + Vector3(0, 0.3, 0))
|
|
await get_tree().create_timer(1.0).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_carcass.png" % prefix)
|
|
print("[world] saved %s_carcass.png" % prefix)
|
|
|
|
## Weather views: a snapped-together hut in clear weather, rain, a storm and
|
|
## snow, and the view out of its open door in the rain.
|
|
func _capture_weather(prefix: String, cam: Camera3D) -> void:
|
|
_respawn()
|
|
player.set_physics_process(false)
|
|
var yaw: float = player.rotation.y
|
|
var hb := Basis(Vector3.UP, yaw)
|
|
var site: Vector3 = build.debug_find_site(player.global_position - player.global_basis.z * 11.0, 3.0)
|
|
var hut: Dictionary = await build.debug_build_hut(site, yaw)
|
|
print("[world] demo hut: %d pieces, failed %s" % [hut.placed, hut.failed])
|
|
var top: float = hut.pieces[0].global_position.y
|
|
spawn_piece(ItemDB.get_item("bed"), Transform3D(hb, site + hb * Vector3(1.0, top - site.y, -0.6)))
|
|
var fire_at: Vector3 = site + hb * Vector3(-0.6, 0, 4.5)
|
|
fire_at.y = terrain.sample_height(fire_at.x, fire_at.z)
|
|
var fire: Node = spawn_piece(ItemDB.get_item("campfire"), Transform3D(hb, fire_at))
|
|
fire.fuel = fire.MAX_FUEL
|
|
var door: Node = null
|
|
for p in hut.pieces:
|
|
if p.item_id == "wood_door":
|
|
door = p
|
|
player.select(4) # wood: nothing lit in hand
|
|
var outside_eye: Vector3 = site + hb * Vector3(4.2, 0, 8.5)
|
|
outside_eye.y = terrain.sample_height(outside_eye.x, outside_eye.z) + 1.7
|
|
var look: Vector3 = site + Vector3(0, 1.4, 0)
|
|
day_night.time = 10.5 / 24.0
|
|
for shot in [["hut_clear", "clear", 10.5], ["hut_rain", "rain", 10.5], ["hut_storm", "storm", 16.0], ["hut_snow", "snow", 11.0]]:
|
|
weather.force(shot[1])
|
|
if shot[1] == "snow":
|
|
weather.snow_cover = 1.0
|
|
weather.ground_wet = 0.0
|
|
day_night.time = float(shot[2]) / 24.0
|
|
day_night.apply(true)
|
|
_aim_camera(cam, outside_eye, look)
|
|
await get_tree().create_timer(2.0).timeout
|
|
if shot[1] == "storm":
|
|
weather.flash = 0.8
|
|
day_night.apply(true)
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_%s.png" % [prefix, shot[0]])
|
|
print("[world] saved %s_%s.png" % [prefix, shot[0]])
|
|
# From inside, out through the open door, in the rain.
|
|
weather.force("rain")
|
|
weather.snow_cover = 0.0
|
|
day_night.time = 17.5 / 24.0
|
|
day_night.apply(true)
|
|
door.set_open(true, false)
|
|
var in_eye: Vector3 = site + hb * Vector3(0.6, top - site.y + 1.6, -1.2)
|
|
_aim_camera(cam, in_eye, site + hb * Vector3(1.2, top - site.y + 1.2, 6.0))
|
|
await get_tree().create_timer(2.0).timeout
|
|
await RenderingServer.frame_post_draw
|
|
get_viewport().get_texture().get_image().save_png("%s_hut_inside.png" % prefix)
|
|
print("[world] saved %s_hut_inside.png" % prefix)
|
|
weather.force("")
|
|
|
|
func _aim_camera(cam: Camera3D, eye: Vector3, at: Vector3) -> void:
|
|
var dir := at - eye
|
|
player.global_position = eye - Vector3(0.0, cam.position.y, 0.0)
|
|
player.rotation = Vector3(0.0, atan2(-dir.x, -dir.z), 0.0)
|
|
cam.rotation.x = atan2(dir.y, Vector2(dir.x, dir.z).length())
|
|
props._update_grass(100000)
|