Admin/Emberwild
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 9 Wiki Activity
Files
04b9d17826fe7b6eb36d8d474f17bf2e14641653
Emberwild/tests/test_tutorial_full.gd

396 lines
16 KiB
GDScript
Raw Blame History

extends SceneTree
## T2 (docs/TUTORIAL_DESIGN.md §7): the whole tutorial, every chapter, played
## by a bot through Actions on the tutorial world (the Valley island, seed
## 1337): first tools, fire and food, hunting, fishing, shelter and night
## (with the demo wolf), sleeping, and the finish card. Materials it would
## take a while to gather by hand (wood for a hut, say) are put in the bag;
## every goal itself is done the way a player does it.
## Run: godot --headless --path . --script res://tests/test_tutorial_full.gd
var _fails := 0
var _finished := false
var A: Node
var S: Node
var DB: Node
var G: Node
var world: Node3D
var player: CharacterBody3D
var inv: Inventory
var sv: Node
var ticked: Array = []
var fire: Node3D
var bench: Node3D
var _pn: Control
func check(cond: bool, what: String) -> void:
print((" ok " if cond else " FAIL ") + what)
if not cond:
_fails += 1
func _initialize() -> void:
_run.call_deferred()
func _run() -> void:
A = root.get_node("Actions")
S = root.get_node("Saves")
DB = root.get_node("ItemDB")
G = root.get_node("Guide")
G.step_done.connect(func(_i, s): ticked.append(String(s.id)))
A.food_rng.seed = 3 # (so raw food doesn't make the bot ill at a bad moment)
S.root_dir = "user://test_worlds"
for w in S.list_worlds():
S.delete_world(w.id)
var TS: Script = load("res://scripts/ui/title_screen.gd")
check(TS.tutorial_world().is_empty(), "no tutorial world yet")
S.current_id = S.create_world("Tutorial", TS.TUTORIAL_SEED, {"tutorial": true})
check(not TS.tutorial_world().is_empty(), "the title screen finds it once it's made (Tutorial, carry on)")
var ts: Node = TS.new()
var page: Control = ts._main_page()
var labels: Array = page.get_children().filter(func(c): return c is Button).map(func(b): return String(b.text))
check(labels.has("Tutorial (carry on)") and not labels.any(func(t): return t.begins_with("Continue")),
"and lists it once: no \"Continue: Tutorial\" as well %s" % [labels.slice(0, 3)])
page.free()
ts.free()
world = load("res://scenes/world.tscn").instantiate()
root.add_child(world)
for _i in range(5):
await physics_frame
player = world.player
player.set_physics_process(false)
player.survival.set_process(false)
world.day_night.frozen = true
world.weather.set_process(false)
world.weather.force("clear")
inv = player.inventory
sv = player.survival
_pn = load("res://scripts/ui/guide.gd").new()
root.add_child(_pn)
_pn.setup(player)
await _body()
check(_finished, "test ran to the end (no script errors)")
for w in S.list_worlds():
S.delete_world(w.id)
DirAccess.remove_absolute(S.root_dir)
print("RESULT: %s (%d failures)" % ["PASS" if _fails == 0 else "FAIL", _fails])
quit(1 if _fails > 0 else 0)
# --- helpers ------------------------------------------------------------------------------
func _at(id: String) -> bool:
return String(G.current().get("id", "")) == id
func _ground(p: Vector3) -> Vector3:
return Vector3(p.x, world.terrain.sample_height(p.x, p.z), p.z)
func _near(p: Vector3, d: float = 1.2) -> void:
var to: Vector3 = player.global_position - p
to.y = 0.0
player.global_position = _ground(p + (to.normalized() if to.length() > 0.1 else Vector3(1, 0, 0)) * d)
func _take(id: String) -> bool:
var best: Node3D = null
var best_d := INF
for pk in world.props.pickups.values():
if is_instance_valid(pk) and not pk.taken and pk.item_id == id:
var d: float = pk.global_position.distance_to(player.global_position)
if d < best_d:
best_d = d
best = pk
if best == null:
return false
player.global_position = best.global_position + Vector3(0.8, 0.0, 0)
return A.pickup(player, best)
func _node(kind: String) -> Node3D:
var best: Node3D = null
var best_d := INF
for n in world.props.resource_nodes.values():
if is_instance_valid(n) and n.kind == kind and not n.depleted:
var d: float = n.global_position.distance_to(player.global_position)
if d < best_d:
best_d = d
best = n
return best
## Puts `id` in hand: swapped into the first hotbar slot (only those can be
## held), like a player dragging it there.
func _hold(id: String) -> int:
for i in range(inv.size()):
var s = inv.get_slot(i)
if s != null and s.id == id:
var tmp = inv.get_slot(0)
inv.set_slot(0, s)
inv.set_slot(i, tmp)
player.select(0)
return 0
return -1
func _fell(n: Node3D) -> void:
_near(n.global_position, 1.4)
var hits := 0
while not n.depleted and hits < 40:
sv.stamina = 100.0
if A.harvest_hit(player, n, n.global_position + Vector3(0, 0.6, 0)):
hits += 1
## Places what's in `id`'s slot on the ground `ahead` metres in front of you.
func _place(id: String, ahead: float, side: float = 0.0) -> Node3D:
var slot := _hold(id)
var f := -player.global_basis.z
var r := player.global_basis.x
for k in range(12):
var at := _ground(player.global_position + f * (ahead + 0.5 * k) + r * side)
var xf := Transform3D(Basis(Vector3.UP, player.rotation.y), at)
if world.placement_valid(DB.get_item(id), xf) and A.place(player, slot, xf, world):
for p in world.all_pieces():
if p.item_id == id and p.global_position.distance_to(at) < 0.05:
return p
return null
func _by_fire() -> void:
_near(fire.global_position, 2.0)
func _step_done(id: String) -> bool:
return ticked.has(id)
func _body() -> void:
await _tools()
await _food()
await _hunt()
await _fishing()
await _night()
_finish()
_finished = true
# --- 1. first tools -------------------------------------------------------------------------
func _tools() -> void:
print("1. first tools")
check(G.active and _at("look"), "the tutorial world starts the tutorial (Old Tam: \"%s\")" % String(G.current().text).left(40))
check(world.wolves == null or not world.wolves.enabled, "a calm island: no wolf pack")
check(world.bears == null, "no bear, nothing stealing food")
G.walked(11.0)
for id in ["stick", "stick", "stick", "stone", "stone", "stone", "fiber", "flint", "flint"]:
_take(id)
check(A.craft(player, "stone_axe"), "an axe")
_hold("stone_axe")
_fell(_node("tree"))
while inv.count("stick") < 2:
_take("stick")
if inv.count("flint") < 1:
_take("flint")
check(A.craft(player, "stone_pickaxe"), "a pickaxe")
_hold("stone_pickaxe")
_fell(_node("rock"))
check(ticked == ["look", "sticks", "flax", "axe", "tree", "pickaxe"], "chapter 1 done: %s" % [ticked])
# --- 2. fire and food -----------------------------------------------------------------------
func _food() -> void:
print("2. fire and food")
check(_at("campfire") and _pn._chapter.text.contains("Fire and food"), "next chapter: Fire and food")
inv.add("stone", 5)
inv.add("stick", 4)
check(A.craft(player, "campfire"), "a campfire, by hand")
fire = _place("campfire", 2.5)
check(fire != null and _step_done("campfire"), "placed: it ticks")
fire.fuel = fire.MAX_FUEL
print(" berries")
G._marker = G.find_marker()
var bush: Node3D = null
for b in world.props.forage.values():
if is_instance_valid(b) and b.ripe() and (bush == null or b.global_position.distance_to(player.global_position) < bush.global_position.distance_to(player.global_position)):
bush = b
check(bush != null and G.marker_position().distance_to(bush.global_position) < 0.05, "the marker's on the nearest ripe bush")
_near(bush.global_position, 1.2)
check(A.forage(player, bush) and inv.count("berries") > 0, "picked")
sv.hunger = 40.0
check(A.eat(player, _hold("berries")) and _step_done("berries"), "and eaten: it ticks")
print(" a mushroom")
check(_take("mushroom"), "found one under the trees")
_by_fire()
check(A.craft(player, "roasted_mushroom") and _step_done("mushroom"), "roasted at the fire: it ticks")
print(" the diet")
check(_at("diet") and _pn._progress.text.is_empty(), "Old Tam explains the diet bars")
var ev := InputEventKey.new()
ev.keycode = KEY_ENTER
ev.pressed = true
_pn._unhandled_input(ev)
check(_step_done("diet"), "Enter carries on")
# --- 3. hunting ------------------------------------------------------------------------------
func _hunt() -> void:
print("3. hunting")
_by_fire()
inv.add("wood", 14)
inv.add("flint", 2)
check(A.craft(player, "workbench"), "a workbench")
bench = _place("workbench", 2.5, 2.5)
check(bench != null and _step_done("workbench"), "placed")
check(A.craft(player, "club") and _step_done("weapon"), "a club: a weapon")
check(_at("rabbit"), "now: %s" % G.current().get("title", "?"))
var rabbits: Array = world.creatures.alive("rabbit")
check(rabbits.size() >= 3, "Old Tam's rabbits are about (%d)" % rabbits.size())
G._marker = G.find_marker()
var rb: Node3D = null
for r in rabbits:
if rb == null or r.global_position.distance_to(player.global_position) < rb.global_position.distance_to(player.global_position):
rb = r
check(G.marker_position().distance_to(rb.global_position) < 0.05, "the marker's on the nearest one")
rb.set_physics_process(false)
_near(rb.global_position, 1.5)
_hold("club")
sv.stamina = 100.0
check(A.melee(player, rb) and rb.is_dead() and _step_done("rabbit"), "one blow with the club")
check(A.butcher(player, rb), "butchered")
_by_fire()
check(A.craft(player, "cooked_meat") and _step_done("cook"), "and the meat cooked: it ticks")
G.continue_step()
check(_step_done("animals"), "(the tip about deer and boars)")
# --- 4. fishing --------------------------------------------------------------------------------
func _fishing() -> void:
print("4. fishing")
_near(bench.global_position, 1.5)
inv.add("stick", 2)
inv.add("fiber", 3)
inv.add("flint", 1)
check(A.craft(player, "fishing_rod") and _step_done("rod"), "a rod at the workbench")
G._marker = G.find_marker()
var shore: Vector3 = G.marker_position()
var t: Node3D = world.terrain
check(shore != Vector3.INF and t.sample_height(shore.x, shore.z) >= t.water_level, "the marker shows the lake shore")
var lake: Vector2 = t.lake_center
var x: float = lake.x
while t.sample_height(x, lake.y) < t.water_level + 0.4 and x < lake.x + 60.0:
x += 0.5
player.global_position = _ground(Vector3(x + 1.0, 0, lake.y))
_hold("fishing_rod")
sv.stamina = 100.0
var origin: Vector3 = player.global_position + Vector3(0, 1.6, 0)
check(A.cast_line(player, origin, Vector3(lake.x, t.water_level, lake.y) - origin, world), "cast")
var tt := 0.0
while tt < 400.0:
var b: Node3D = world.bobber
if b == null or b.state == "biting":
break
b.set_physics_process(false)
b.step(0.05)
tt += 0.05
check(world.bobber != null and world.bobber.state == "biting", "a bite (after %.0f s)" % tt)
check(A.reel(player, world), "landed it")
var fish := "perch" if inv.count("perch") > 0 else "trout"
_by_fire()
check(A.craft(player, "grilled_" + fish) and _step_done("fish"), "grilled: it ticks")
# --- 5. shelter and night ----------------------------------------------------------------------
func _night() -> void:
print("5. shelter and night")
check(_at("hut"), "now: build a hut")
print(" the outline")
var ol: Node3D = G.outline
check(ol != null and ol.slots.size() == 20 and ol.refresh() == 20, "Old Tam marks out a hut: a 20-piece outline")
check(ol.center().distance_to(fire.global_position) < 9.0 and ol.center().distance_to(fire.global_position) > 3.0,
"near the fire, on clear ground (%.0f m away), not on it" % ol.center().distance_to(fire.global_position))
G._marker = G.find_marker()
check(G.marker_position().distance_to(ol.center()) < 0.05, "the marker points at it")
var slot0: Transform3D = ol.slots[0][1]
var aim := {"position": slot0.origin + Vector3(0.9, 0, -0.7), "normal": Vector3.UP, "collider": world.terrain.get_node("TerrainBody")}
var r: Dictionary = world.build.placement(DB.get_item("wood_floor"), aim, player.rotation.y + 0.4)
check(r.ok and r.xf.origin.distance_to(slot0.origin) < 0.01, "a floor aimed near its place in the outline goes right in")
var yaw: float = ol.origin.basis.get_euler().y
var hut: Dictionary = await world.build.debug_build_hut(ol.center(), yaw)
for _i in range(3):
await physics_frame
check(hut.placed == 20, "a hut (the same snapping a player uses: %d pieces)" % hut.placed)
check(not is_instance_valid(ol) or ol.is_queued_for_deletion() or ol.refresh() == 0, "every piece of the outline filled")
var b := Basis(Vector3.UP, yaw)
var center: Vector3 = hut.pieces[0].global_transform * Vector3(1, 0, 1)
check(center.distance_to(ol.center() if is_instance_valid(ol) else center) < 0.05, "(built right on it)")
for _i in range(3):
await physics_frame
var under := 0
var space: PhysicsDirectSpaceState3D = world.get_world_3d().direct_space_state
for pk in world.props.pickups.values():
if pk.taken or Vector2(pk.global_position.x - center.x, pk.global_position.z - center.z).length() > 5.0:
continue
var rq := PhysicsRayQueryParameters3D.create(pk.global_position + Vector3(0, 0.02, 0), pk.global_position + Vector3(0, 2.6, 0))
rq.collision_mask = 4
rq.hit_from_inside = true
if not space.intersect_ray(rq).is_empty():
under += 1
check(under == 0, "no flax, sticks or stones poking up through the floor (%d left)" % under)
player.global_position = center + b * Vector3(0.6, 0.05, -0.6)
sv._shelter_left = 0.0
sv.step(0.2)
G.poll()
check(_step_done("hut"), "stand inside out of the weather: it ticks")
print(" the bed")
_near(bench.global_position, 1.5)
inv.add("wood", 8)
inv.add("fiber", 6)
check(A.craft(player, "bed"), "a bed at the workbench")
player.global_position = center + b * Vector3(0.6, 0.05, 0.9)
var slot := _hold("bed")
var bxf := Transform3D(b, center + b * Vector3(-0.5, 0, -0.4))
check(world.placement_valid(DB.get_item("bed"), bxf) and A.place(player, slot, bxf, world), "put inside")
var bed: Node3D = null
for p in world.all_pieces():
if p.item_id == "bed":
bed = p
check(A.use_bed(player, bed), "E on it: spawn set")
G.poll()
check(_step_done("bed"), "it ticks")
print(" nightfall")
check(_at("torch") and world.day_night.hours() >= 18.5, "the sun goes down (%.1f h)" % world.day_night.hours())
inv.add("stick", 1)
inv.add("fiber", 2)
check(A.craft(player, "torch") and _step_done("torch"), "a torch")
print(" the wolf")
check(_at("wolf") and G.demo_wolf != null, "a wolf comes out of the dark")
var w: Node3D = G.demo_wolf
var hp0: float = sv.health
var closest := INF
var t := 0.0
while is_instance_valid(w) and not w.is_queued_for_deletion() and t < 60.0:
w.set_physics_process(false)
w.step(0.1)
closest = minf(closest, w.global_position.distance_to(player.global_position))
t += 0.1
if int(t * 10) % 10 == 0:
await physics_frame
check(_step_done("wolf"), "it circles, then slinks off (%.0f s)" % t)
check(sv.health == hp0 and closest > 6.0, "never closer than %.0f m, and never bites" % closest)
print(" sleep")
check(_at("sleep") and world.day_night.hours() >= 20.9, "bedtime (%.1f h)" % world.day_night.hours())
player.global_position = center + b * Vector3(0.6, 0.05, 0.9)
check(A.use_bed(player, bed), "into bed")
check(_step_done("sleep"), "slept till morning: it ticks")
func _finish() -> void:
print("finished")
var order := []
for s in G.steps:
order.append(String(s.id))
check(ticked == order, "all %d steps ticked, in order" % order.size())
check(G.is_finished(), "the tutorial is done")
check(_pn.card != null and is_instance_valid(_pn.card), "Old Tam's goodbye card is up")
var buttons: Array = _pn.card.find_children("*", "Button", true, false)
check(buttons.size() == 2 and buttons[0].text == "Start your own world" and buttons[1].text == "Keep exploring",
"with Start your own world and Keep exploring")
_pn._on_keep_exploring()
check(_pn.card == null and not player.ui_open, "Keep exploring: back to the island")
print("skipping")
# (With nothing counted yet, so the next step doesn't tick at once.)
var idx: int = G.index
var saved: Dictionary = G.counters.duplicate()
G.counters = {}
G.index = 3
G.skip()
check(G.index == 4 and String(G.current().id) == "tree", "(Skip step moves on: the pause menu's button)")
G.index = idx
G.counters = saved
Reference in New Issue View Git Blame Copy Permalink