diff --git a/src/features/editScene/AGENTS.md b/src/features/editScene/AGENTS.md index cea95e1..c10d003 100644 --- a/src/features/editScene/AGENTS.md +++ b/src/features/editScene/AGENTS.md @@ -251,6 +251,22 @@ xvfb-run -a ./demoSokoban demo_scene_exterior.json \ # while driving, R/F = raise/lower the fork while driving, Escape = # pause menu (frees the cursor). +# Demo: taxi driver demo (demos/demo-taxi, target demoTaxi). Starts as +# an exact copy of demo-interior-exterior-dynamics (same +# interior/exterior scenes, streaming terrain, scene-switch doors, +# --test-switch contract); the taxi game (procedural town generation, +# drivable sedans, passenger/foot-traffic/vehicle-traffic NPCs, chained +# timed fares with doubling payout) is added step by step - see +# demos/demo-taxi/PLAN.md. Vehicle ideas come from demo-sokoban. +cd demos/demo-taxi +./demoTaxi +# ...or headless smoke run (one frame, then exit): +./demoTaxi --headless --exit-after-first-frame +# ...or headless end-to-end check of the inherited scene contract: +./demoTaxi --headless --test-switch +# Controls: mouse = look, W/A/S/D = move, Shift = run, E = use door, +# Escape = pause menu (frees the cursor). + # Road wedge/segment self-intersection regression test (no scene needed, # also registered as CTest roadGeometryOverlapTest) diff --git a/src/features/editScene/CMakeLists.txt b/src/features/editScene/CMakeLists.txt index c9f3f5c..344d8b7 100644 --- a/src/features/editScene/CMakeLists.txt +++ b/src/features/editScene/CMakeLists.txt @@ -1064,3 +1064,4 @@ add_subdirectory(demos/demo-scene-switching) add_subdirectory(demos/demo-scene-switching-extra) add_subdirectory(demos/demo-interior-exterior-dynamics) add_subdirectory(demos/demo-sokoban) +add_subdirectory(demos/demo-taxi) diff --git a/src/features/editScene/demos/demo-taxi/CMakeLists.txt b/src/features/editScene/demos/demo-taxi/CMakeLists.txt new file mode 100644 index 0000000..902e4ed --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/CMakeLists.txt @@ -0,0 +1,127 @@ +# --------------------------------------------------------------------------- +# demo-taxi — taxi driver demo: procedurally generated town, drivable sedans, +# passenger/foot-traffic/vehicle-traffic NPCs, chained taxi fares +# --------------------------------------------------------------------------- +# Starts as an exact copy of demos/demo-interior-exterior-dynamics (same +# scene-switch-door setup, same streaming-terrain/sky/water exterior at +# world center ~(4000, 4000)); the taxi game (town generation, sedans, +# NPC traffic, fare chain) is built step by step on top of it - see +# PLAN.md in this directory. Vehicle ideas come from demos/demo-sokoban +# (Jolt VehicleConstraint, VehicleControllerSystem enter/exit flow). +# +# The executable is self-contained in this build directory: a POST_BUILD +# step (stage_runtime.cmake) copies resources.cfg, the +# character prefab (prefabs/char_2.json, written by a previous editor/game +# run) and any runtime config JSONs here, and symlinks both demo scenes +# (demo_scene_interior.json / demo_scene_exterior.json, so scene edits in +# the source tree are visible without a rebuild) plus the big pre-staged +# runtime directories (resources/, characters/, lua-scripts/) from the +# editScene binary directory; the terrain heightmap is staged separately +# by configure_file (see below) so source changes re-copy it on the next +# build. Run it from here: +# cd /src/features/editScene/demos/demo-taxi +# ./demoTaxi +# Controls: mouse = look, W/A/S/D = move, Shift = run, E = use door, +# Escape = pause menu (frees the cursor). + +get_filename_component(EDITSCENE_SOURCE_DIR + "${CMAKE_CURRENT_SOURCE_DIR}/../.." ABSOLUTE) +get_filename_component(EDITSCENE_BINARY_DIR + "${CMAKE_CURRENT_BINARY_DIR}/../.." ABSOLUTE) + +# Reuse the editScene sources, swapping main.cpp for demo_main.cpp. +set(DEMO_SOURCES ${EDITSCENE_SOURCES}) +list(REMOVE_ITEM DEMO_SOURCES main.cpp) +list(TRANSFORM DEMO_SOURCES PREPEND "${EDITSCENE_SOURCE_DIR}/") + +# --- Embedded project configuration (F8 release binary) --------------- +# Read project.json at configure time and embed its parameters into the +# binary via a generated project.h, so the release binary is attached to +# its project directory without needing --project. Editing project.json +# re-triggers the CMake configure step (CMAKE_CONFIGURE_DEPENDS). +set(PROJECT_JSON_PATH "${CMAKE_CURRENT_SOURCE_DIR}/project.json") +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + "${PROJECT_JSON_PATH}") +file(READ "${PROJECT_JSON_PATH}" PROJECT_JSON_TEXT) +string(JSON PROJECT_APP_NAME GET "${PROJECT_JSON_TEXT}" appName) +string(JSON PROJECT_START_SCENE GET "${PROJECT_JSON_TEXT}" startScene) +string(JSON PROJECT_GAME_MODE GET "${PROJECT_JSON_TEXT}" gameMode) +if(PROJECT_GAME_MODE) + set(PROJECT_GAME_MODE_VALUE 1) +else() + set(PROJECT_GAME_MODE_VALUE 0) +endif() +configure_file("${CMAKE_CURRENT_SOURCE_DIR}/project.h.in" + "${CMAKE_CURRENT_BINARY_DIR}/generated/project.h" @ONLY) + +# Terrain heightmap for the exterior scene's terrain entity (terrainId +# 4242424300000001, heightmapFile heightmap.bin — TerrainSystem resolves it +# as heightmaps// relative to the CWD). Generated +# in the source tree by gen_heightmap.py. The terrain runs in streaming +# mode (base heights come from baseNoise, not the heightmap), but the file +# stays staged so flipping streamingEnabled off keeps working. A +# configure_file COPYONLY copy is used on purpose: it registers a configure +# dependency on the source file, so regenerating heightmap.bin re-copies it +# into the staging directory on the next build without manual intervention. +configure_file("${CMAKE_CURRENT_SOURCE_DIR}/heightmap.bin" + "${CMAKE_CURRENT_BINARY_DIR}/heightmaps/4242424300000001/heightmap.bin" + COPYONLY) + +add_executable(demoTaxi + demo_main.cpp + ${DEMO_SOURCES} +) + +target_compile_definitions(demoTaxi + PRIVATE EDITSCENE_HAS_EMBEDDED_PROJECT) + +add_dependencies(demoTaxi morph) + +# Define JPH_DEBUG_RENDERER for physics debug drawing (same as editor) +target_compile_definitions(demoTaxi PRIVATE JPH_DEBUG_RENDERER) + +target_link_libraries(demoTaxi + OgreMain + OgreBites + OgreOverlay + OgreMeshLodGenerator + OgrePaging + OgreTerrain + flecs::flecs_static + nlohmann_json::nlohmann_json + Jolt::Jolt + OgreProcedural::OgreProcedural + RecastNavigation::Recast + RecastNavigation::Detour + RecastNavigation::DetourTileCache + RecastNavigation::DetourCrowd + RecastNavigation::DebugUtils + PackageArchive + RoadGeometryLib + lua + SDL2::SDL2 +) + +target_include_directories(demoTaxi PRIVATE + ${CMAKE_CURRENT_BINARY_DIR}/generated + ${EDITSCENE_SOURCE_DIR} + ${EDITSCENE_SOURCE_DIR}/recastnavigation/Recast/Include + ${EDITSCENE_SOURCE_DIR}/recastnavigation/Detour/Include + ${EDITSCENE_SOURCE_DIR}/recastnavigation/DetourTileCache/Include + ${EDITSCENE_SOURCE_DIR}/recastnavigation/DetourCrowd/Include + ${EDITSCENE_SOURCE_DIR}/recastnavigation/DebugUtils/Include + ${CMAKE_SOURCE_DIR}/src/FastNoiseLite + ${CMAKE_SOURCE_DIR}/src/lua/lua-5.4.8/src + ${CMAKE_SOURCE_DIR}/src/lua/lpeg-1.1.0 +) + +# Stage the standalone runtime next to the executable (see header comment). +add_custom_command(TARGET demoTaxi POST_BUILD + COMMAND ${CMAKE_COMMAND} + -DDEMO_DIR=${CMAKE_CURRENT_BINARY_DIR} + -DEDITSCENE_BIN=${EDITSCENE_BINARY_DIR} + -DEDITSCENE_SRC=${EDITSCENE_SOURCE_DIR} + -DSRC_DIR=${CMAKE_CURRENT_SOURCE_DIR} + -P "${CMAKE_CURRENT_SOURCE_DIR}/stage_runtime.cmake" + COMMENT "Staging demo-taxi standalone runtime" +) diff --git a/src/features/editScene/demos/demo-taxi/PLAN.md b/src/features/editScene/demos/demo-taxi/PLAN.md new file mode 100644 index 0000000..fbe6b9b --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/PLAN.md @@ -0,0 +1,432 @@ +# demo-taxi — Implementation Plan + +**Status: Phase 0 done (2026-09-15).** Demo skeleton only; all game +phases pending. This plan is a working draft — phases get refined, +split or reordered as we work through them. + +Taxi driver demo in the open world of `demo_scene_exterior.json`: a +procedurally generated (but tightly controlled) settlement on the +streaming terrain, two drivable sedan-type cars for the player, taxi +passenger NPCs, foot-traffic NPCs on sidewalks, vehicle traffic with +NPC drivers, and a fare chain — the player must complete 10 taxi fares, +each fare paying double the previous one, delivering each passenger +within a time limit derived from the trip distance. Missing the timer +fails the whole mission and resets the chain. + +This demo starts as an exact copy of `demo-interior-exterior-dynamics` +(scene-switch doors interior <-> exterior, streaming terrain +archipelago, sky, water). Vehicle ideas come from `demo-sokoban` +(Jolt `VehicleConstraint`, `VehicleControllerSystem` enter/exit flow, +`--test-vehicle*` headless test patterns). + +## Goals / non-goals + +Goals: + +- **Easy procedural creation of settlements.** Today building a town + by hand (roads node-by-node, lots/buildings one by one) takes + endless amounts of time. The headline improvement of this demo is + generator tooling: a road-network generator and a town generator + with explicit, controllable parameters and deterministic seeds, so a + village/town/city is a parameter choice, not a week of clicking. +- **Multiple streamed settlements.** One settlement occupies a square + of at most 1000 x 1000 m; the world can hold several of them. + Everything streams (terrain pages, road/spawner region stores, + navmesh tiles, NPC and traffic spawn radii) so FPS stays good. +- **Enterable buildings.** Every generated building can be entered + through an F1 scene-switch door; the matching interior is generated + on the fly (deterministic from the building's exterior parameters). + Until that phase lands, exterior doors stay disabled. +- **NPC and vehicle control infrastructure.** AI-driven vehicles on + the road graph, pedestrians on sidewalks, passengers entering and + leaving the player's taxi — all reusable engine systems, not demo + hacks. +- **Realistic foot traffic.** People leave their houses, walk along + the sidewalks and join other pedestrians — or walk to their own + vehicle, get in and join the vehicle traffic. +- **The taxi game loop** on top: pickup -> timed drive -> dropoff -> + next fare, doubling payout, 10 fares to win. + +Non-goals (for now): + +- No multiplayer, no traffic-code simulation beyond what gameplay needs + (speed limits, intersection priority, basic collision avoidance). +- No full economy/quest system — the fare chain is a self-contained + activity like the sokoban yard (Lua rules + GlobalStateStore + HUD). + +## Design decisions (agreed with the user) + +- **Engine-level, not demo-level** (same rule as demo-sokoban): all new + components/systems/Lua APIs live in `src/features/editScene` + (`components/`, `systems/`, `lua/`, `ui/`, road generators next to + `roadlib/`) so any demo or scene can use them. `demo-taxi` itself + contributes scene JSON data, assets, demo-owned config and headless + test listeners in `demo_main.cpp` — no game logic in the demo binary. +- **Lua runs the game rules** (same pattern as `sokoban.lua`): C++ + provides per-frame physics-adjacent detection and emits `EventBus` + events; fare rules (price doubling, timers, completion) live in a + shared Lua module (e.g. `lua-scripts/taxi.lua`). No per-frame Lua + polling beyond the existing throttled `frame` event pattern. +- **Deterministic generation**: every procedural step (road network, + town layout, interiors, NPC placement) takes an explicit seed; same + seed + same parameters = same town. Generated output is *data in + the existing formats* (RoadGraph nodes/edges in road region files, + scene entities, spawner defs), so it remains hand-editable + afterwards — generation is a starting point, not a black box. +- **Streaming-compatible**: the exterior terrain keeps + `streamingEnabled`; generated content must land in the region stores + (`heightmaps//roads/`, `.../spawners/`) when streaming, + inline otherwise. A settlement fits in a 1000 x 1000 m square so a + settlement's content covers at most one terrain page (2000-unit + pages) plus margin; multiple settlements sit in different regions of + the same world. +- **Vehicles**: several sedan types, each in multiple colors, for both + the player cars and traffic. Many more vehicle types come later + (Phase 11); the vehicle pipeline must not hardcode "sedan". +- **Fare failure**: missing the delivery timer fails the whole + mission — the chain resets to fare 1 and the payout multiplier is + lost. +- **Feature numbering**: `GameFeatures202609.md` has F0–F12 used; new + engine features from this plan get F13+ entries there as they land, + and AGENTS.md files are updated per the project rules. + +## Existing pieces we build on + +- `VehicleComponent` / `VehicleSystem` (F10) — Jolt `VehicleConstraint` + + `WheeledVehicleController`, per-wheel suspension/steering params, + wheel/steering-wheel visuals, camera boom fields. The sedan is a + configuration of this (front steer, no fork, higher speed). +- `VehicleControllerSystem` (F10) — player enter/exit (`vehicle_enter` + event, seat pinning, driving camera, controls hint). Passenger + seating will extend this. +- `RoadSystem` + `roadlib/RoadGeometryLib` — per-terrain `RoadGraph`, + wedge/segment geometry with colliders, sidewalks, roadside prefab + slots, terrain compliance both directions, M5 region streaming. + Intersections already work at the visual level (wedge fans join + edges at multi-neighbor nodes). `ProceduralRoadGeometry.md` + documents the geometry; `ProceduralRoadGeometryImprovement.md` + tracks known improvements. +- `TownComponent` / `DistrictComponent` / `LotComponent` + + `CellGridSystem` — procedural building generation with a + Town -> District -> Lot material/template hierarchy (currently + circle-arranged districts; the generators below replace the tedious + manual arrangement, not the building generator). CellGrid supports + multi-storey buildings (`height` = floors) but generates no stairs, + so upper floors are unreachable. +- Scene switching (F1 scene-switch doors, `EditorApp::switchScene`, + per-scene arrival targets) — the mechanism enterable buildings build + on; `demo_scene_interior.json`/`demo_scene_exterior.json` in this + demo are the working example. +- `NavMeshSystem` (tile cache) + `PathFollowingSystem` — pedestrian + locomotion on navmesh, door-aware; Recast climbs geometry within the + configured step height, so stair geometry is navmesh-compatible. +- `CharacterSpawnerSystem` + `CharacterRegistry` + animation trees — + distance-based NPC spawn/despawn; streamed spawner region store (M4). +- GOAP / BehaviorTree / SmartObject / Actuator systems — NPC behaviour + glue and player interaction prompts. +- `ZoneSystem` / `TargetZoneComponent` (F11) — generic zone detection, + reusable for pickup/dropoff curbs. +- `GameHudSystem` + `ecs.hud.*` (F12) — status lines and banners. +- `GlobalStateStore` (F9) — persistent fare-chain state + (`taxi.fare.index`, `taxi.money`, ...). +- `EventBus`, `SceneScriptComponent`, `lua-examples/` — event/Lua glue. +- Demo scaffolding in this directory (CMake target, embedded + `project.json`, symlinked scenes, `--headless` smoke and + `--test-switch` listener patterns in `demo_main.cpp`). +- demo-sokoban reference material: sedan-relevant tuning gotchas in + `AGENTS.md` ("VehicleSystem (F10)"), its `animation_tree.json` + "driving" state, `--test-vehicle-drive` headless test flow, + `assets/blender/scripts/gen_sokoban_assets.py` as the asset-generator + script pattern. + +## Pieces that do not exist yet (to build) + +1. Sedan vehicles: no car meshes, no car-tuned `VehicleComponent` + preset. Reference models exist + (`assets/blender/vehicles/Car5_Taxi.blend`, + `assets/blender/vehicles/Car2.blend`) but cannot be used directly — + they lack separate doors, wheels, trunk and engine cover. +2. Road geometry improvements: intersection wedges are not smoothed at + the edge and often overlap because too little space is reserved for + lanes and sidewalks; the procedural lane template emits front/back + geometry even where the intersection should be open; terrain + compliance is manual and tedious. +3. Road-network generation: roads are authored node-by-node with the + Connect tool today; no layout generator. +4. Town generation: District/Lot exist but arrange lots in a circle + and require manual setup; no road-following lot placement, no + village/town/city presets. We need road-specific lot components + that place buildings along road frontages — from CellGrid templates + or plain prefabs — with easy-to-set parameters. +5. Stair generation: CellGrid multi-storey buildings (`height` > 1) + have stacked floors with no connection between them — no stair + cells, no floor openings, nothing for the character or the navmesh + to climb. +6. On-the-fly interiors: no way to generate an interior scene matching + a generated building's exterior at scene-switch time. +7. AI vehicle driving: vehicles are player-only; no road-following AI + driver, no speed/intersection logic, no NPC seated in a vehicle. + Intersections have no traffic controls (priority rules) at all. +8. Foot traffic: no pedestrian wandering/scheduling on sidewalks, no + house -> sidewalk -> own-car flows. +9. Passenger mechanics: no NPC vehicle boarding/alighting, no + passenger seat, no hail/pickup flow. +10. Fare chain: no fare/timer/money rules (Lua module + HUD). +11. Assets: sedans (several types x several colors, one taxi-marked), + possibly street props (lamps, signs). + +## Phases + +Each phase ends in a buildable, runnable demo with headless +verification; verification commands assume the build tree (e.g. +`build-vscode`) is configured. Phase scopes below are initial +estimates — expect splits as we learn. + +### Phase 0 — Demo skeleton — DONE (this step) + +Copy of `demo-interior-exterior-dynamics` with target `demoTaxi`, +`project.json` appName `demo-taxi`, registered via +`add_subdirectory(demos/demo-taxi)` in +`src/features/editScene/CMakeLists.txt`. + +Verify: +```bash +cmake --build build-vscode --target demoTaxi -j4 +cd build-vscode/src/features/editScene/demos/demo-taxi +./demoTaxi --headless --exit-after-first-frame +./demoTaxi --headless --test-switch # inherited scene contract +``` + +### Phase 1 — Sedan vehicles + +- New sedan meshes through the Blender asset pipeline (pattern: + `gen_sokoban_assets.py`), using the reference models + `assets/blender/vehicles/Car5_Taxi.blend` (taxi) and + `assets/blender/vehicles/Car2.blend` (plain sedan) as shape + references. They cannot be used directly — they lack separate + doors, wheels, trunk and engine cover — so the export splits those + parts. Scale to real car dimensions: length ~5 m, width ~1.9 m, + height ~1.2 m (wheels modelled at the origin like the forklift's). +- Several sedan types (silhouette variants) x several colors/materials + so traffic is distinguishable; one type is taxi-marked (sign/roof + marking). Keep the pipeline generic — many more vehicle types come + in Phase 11. +- Car-tuned `VehicleComponent`: front-wheel steering (no `rearSteer`), + no fork, higher `maxTorque`/gearing than the forklift, sedan + `cameraDistance`/`cameraHeight`, `seatOffset`. +- Demo-owned `animation_tree.json` (copy demo-sokoban's — it carries + the "driving" locomotion state). +- Two player sedans parked in the exterior scene near the content + site, enterable via the existing `vehicle_drive` actuator action. + Only one of them is the taxi and starts the taxi loop; the other is + for plain driving. +- Headless: `--test-vehicle-drive`-equivalent for the sedan (spawn, + enter, drive, steer, brake, exit) on a flat test scene. + +### Phase 2 — Road geometry & compliance improvements + +Geometry-level fixes that both hand editing and the Phase 3 generator +need (intersections already work visually; this makes them correct and +terrain-friendly): + +- Intersection inner geometry: the procedural lane template must not + emit front/back geometry at multi-neighbor nodes (open junction + area); front/back caps only for single-neighbor (dead-end) nodes. +- Intersection overlap: smooth the wedge edges at intersections and + reserve enough space for lanes + sidewalks so adjacent wedges stop + overlapping. +- Compliance workflow: make terrain compliance automatic instead of + tedious — a single action (and an automatic pass after generation) + that chains roads-to-terrain and terrain-to-roads until stable. +- Headless: extend/reuse the `road_geometry_overlap_test` machinery — + no self-intersections at 3-/4-way nodes, dead-end caps present, + compliance pass converges and is idempotent. + +### Phase 3 — Road-network generator + +The tedious part today: every node/edge is hand-placed. Build a +generator that emits a `RoadGraph` (region files when streaming): + +- Grid layout first (block size, road width, jitter), explicit seed, + fully deterministic. (Organic/radial layouts are deferred to + Phase 11.) A network is bounded to the settlement square + (max 1000 x 1000 m); generating another settlement is just another + generator invocation at a different origin. +- Terrain-aware placement: sample `getHeightAt`, reject or relocate + segments over water or too-steep slopes, then run the Phase 2 + automatic compliance pass. +- Editor entry point: a "Generate Road Network" panel on the terrain + (parameters, seed, generate/regenerate, clear). +- Headless: generate a network, assert node/edge counts, intersection + valences, no self-intersections, region files written and reload + identically; two settlements in one world do not interfere. + +### Phase 4 — Procedural town generation + +On top of the generated road network: + +- Road-side lot components (new): lots derived from road-edge + frontages (frontage/depth parameters), each placing a building from + a CellGrid template or a plain prefab, with easy-to-set parameters. +- District zoning presets (village / town / city-residential / + city-center) driving building templates, heights, densities. +- Building placement: orient to the street, snap to terrain, run + terrain compliance per lot. Every building gets its (disabled for + now) F1 scene-switch exterior door config, so Phase 8 only has to + enable and wire them. +- Street props: sidewalks everywhere (RoadConfig), roadside prefab + slots for lamps/signs/trees where appropriate. +- Spawnable points of interest: named curbs/stops that later phases + use as passenger pickup/dropoff locations (and as pedestrian + origins/destinations). +- Streaming budget: all settlement content goes through the region + stores (roads, spawners) or distance-based spawn/despawn so an + unloaded settlement costs nothing; two settlements in one world + stream independently. +- Deterministic seed; generated entities stay editable scene/spawner + data (region stores when streaming). +- Headless: generate the demo town, assert building count per zone, + all buildings on dry land above water level, every building carries + its (disabled) scene-switch door config, navmesh rebuilds. + +### Phase 5 — NPC vehicle traffic + +- AI driver system (new, engine-level): a vehicle follows the road + graph (route = path over edges), respects per-edge speed limits, + basic collision avoidance (raycast/whisker braking for the vehicle + ahead and for the player). +- Intersection traffic controls: priority rules on intersection nodes + (the visual intersections from Phase 2 get behaviour), AI drivers + slow/stop/yield accordingly. +- NPC driver characters seated in the vehicles (visual occupancy; + reuse the seat-pinning approach of `VehicleControllerSystem`). +- Traffic vehicles drawn from the Phase 1 sedan pool (type + color + variants). +- Traffic density control: spawn/despawn traffic vehicles by distance + to the camera (spawner pattern), cap active count. +- Headless: two AI cars on a generated loop complete N laps without + collision/assert; intersection yield check; despawn/respawn + stability. + +### Phase 6 — Foot traffic NPCs + +- Pedestrian system: spawners at houses/POIs, pedestrians walk navmesh + routes along sidewalks between points of interest, avoid standing on + the road, despawn by distance. +- Realistic flows: a pedestrian leaves a house (door/curb POI), joins + the sidewalk traffic, and either walks to a destination or enters + their own parked vehicle and drives off as traffic (hand-off to the + Phase 5 AI driver); the reverse flow parks and walks home. (Real + walk-through-interior exits arrive with Phase 8; until then "leaving + a house" starts at its door POI.) +- Uses existing `NavMeshSystem` + `PathFollowingSystem` + + `CharacterSpawnerSystem`; the new work is orchestration data + (sidewalk waypoint extraction from the road graph) plus the flow + scheduler. +- Headless: pedestrians spawn, reach waypoints, never path through + building interiors; house -> car hand-off completes; counts stay + within caps while the camera moves. + +### Phase 7 — CellGrid stair generation + +Multi-storey CellGrid buildings (`height` > 1) generate stacked floors +with no connection between them — interiors above ground level are +unreachable. Add stairs to the CellGrid generator (engine-level, not +taxi-specific): + +- Stair cell: a cell flag (like the existing door/window flags) marking + a stairwell; the generator cuts the matching opening in the + floor/ceiling above and emits a stair mesh (steps sized within the + Jolt character's and Recast's climb limits) plus walkable colliders. +- Placement rules: stairwell position comes from the room layout + (RoomLayoutSystem integration) or an explicit cell flag in + hand-authored grids; a stairwell column stacks through all floors. +- Navmesh: stairs rasterize as walkable (Recast step/slope limits), so + NPCs can path between floors; verify doorway-area costs and door + obstacles still behave. +- Editor + serialization + Lua binding, per the component rules + (serialized flag, Cell Grid editor toggle, `cellgrid_door_test`-style + headless coverage). +- Headless: multi-floor grid with a stairwell — character walks from + ground floor to the top floor (physics), navmesh query finds a + ground->top path; grids without stair flags are unchanged. + +### Phase 8 — Enterable buildings (on-the-fly interiors) + +- Interior scene generator (new, engine-level): given a building's + exterior parameters (footprint, floors, template, seed), generate + the matching interior scene deterministically — same building, same + interior, every visit. Generated as a scene at switch time (or + cached on first visit), not pre-authored per building. Multi-storey + buildings get Phase 7 stairwells so every floor is traversable. +- Enable the F1 scene-switch exterior doors prepared in Phase 4 + (doorConfigs `disabled` -> wired with `sceneSwitchPath`/target); + entering switches to the generated interior, the interior's exit + door switches back to the player's exterior position. +- Interior content level for v1: walls/floor/ceiling/stairs/windows + matching the exterior shell, no furniture gameplay. +- Headless: for N generated buildings, enter -> interior loads and + matches exterior footprint -> exit returns to the curb; two visits + produce identical interiors (determinism check); a multi-storey + building's upper floor is reachable by stairs. + +### Phase 9 — Taxi passengers + +- Passenger NPCs waiting at curbs/POIs; hail interaction (E prompt via + ActuatorSystem or proximity hail while driving slowly). +- NPC boarding/alighting: walk to the car door, play sit state, ride + as passenger (new passenger-seat support — vehicle carries extra + seated NPCs; extends `VehicleComponent` with a seat list), walk away + at dropoff. +- Destination assignment: passenger names a POI/curb from the + generated town (any settlement in the world); route distance + computed over the road graph (drives the fare timer). +- Headless: scripted passenger boards, rides, alights at destination; + vehicle carries passenger through a scene-physics run. + +### Phase 10 — Fare chain gameplay (the taxi game) + +- `lua-scripts/taxi.lua` (pattern of `sokoban.lua`): fare state + machine (awaiting fare -> passenger aboard -> delivered/failed), + price doubling per completed fare (fare 1 = base price, fare 10 = + base * 512), timer from road-graph route distance (e.g. distance / + expected speed * slack factor), money counter. +- Failure rule: missing the timer fails the whole mission — chain + resets to fare 1, multiplier lost, HUD banner explains. +- `GameHudSystem` display: current fare index n/10, fare price, time + remaining, total money; banners on pickup/delivery/fail; win banner + after fare 10. +- Persistence in `GlobalStateStore` under `taxi.*` so the chain + survives scene switches and save/load. +- Headless: scripted 3-fare run asserting prices double, timer scales + with distance, a timeout resets the chain to fare 1, completion + events fire, HUD state updates. + +### Phase 11 — Generator extras & vehicle variety (as needed) + +Less critical items deferred from earlier phases; pull in when the +demo needs them: + +- Organic layout (looped/curved arterial + side streets) and radial + village layout for the road generator. +- Bulk-edit ops for road graphs (delete region, translate/rotate + selection) — generation makes these necessary sooner or later. +- Asymmetric roads (different lane/sidewalk setup per side) and road + narrowing/widening along an edge. +- Generation preview in the editor (ghost overlay before committing). +- More vehicle types beyond sedans (the Phase 1 pipeline is already + generic): vans, trucks, buses; service vehicles. + +### Phase 12 — Demo assembly, polish, docs + +- Assemble the full demo scene: at least one full settlement on the + exterior terrain (optionally a second one to prove + multi-settlement streaming), two player sedans, traffic + + pedestrians + passengers live, interior scene kept as the + "home"/menu-adjacent space. +- Balance pass: speeds, timers, fare slack, traffic density. +- Performance pass: streaming radii, navmesh tile budget, active NPC + caps — measure FPS with both settlements placed. +- Docs: update `AGENTS.md` (both levels), `GameFeatures202609.md` + (F13+ entries), demo README section; full headless test battery + wired into the demo like demo-sokoban's. diff --git a/src/features/editScene/demos/demo-taxi/demo_main.cpp b/src/features/editScene/demos/demo-taxi/demo_main.cpp new file mode 100644 index 0000000..51eb3b3 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/demo_main.cpp @@ -0,0 +1,983 @@ +#include +#include +#include "EditorApp.hpp" +#include "ProjectConfig.hpp" +#include "camera/EditorCamera.hpp" +#include "systems/CharacterRegistry.hpp" +#include "systems/DoorSystem.hpp" +#include "systems/PlayerControllerSystem.hpp" +#include "systems/TerrainSystem.hpp" +#include "systems/EventBus.hpp" +#include "systems/GlobalStateStore.hpp" +#include "components/Door.hpp" +#include "components/EntityName.hpp" +#include "components/Transform.hpp" +#include +#include +#include + +#ifdef EDITSCENE_HAS_EMBEDDED_PROJECT +#include "project.h" +#endif + +struct ExitAfterFirstFrameListener : public Ogre::FrameListener { + Ogre::Root *root; + bool triggered = false; + ExitAfterFirstFrameListener(Ogre::Root *r) : root(r) {} + bool frameRenderingQueued(const Ogre::FrameEvent &) override + { + if (!triggered) { + triggered = true; + root->queueEndRendering(); + } + return true; + } +}; + +/* Debug capture aid (for offscreen/xvfb screenshots): + * --force-pos x y z yawDeg [pitchDeg] + * teleport the player character once, as + * soon as it is alive (physics picks the + * new position up through the usual + * node->physics sync, gravity/buoyancy + * then act naturally); yaw/pitch (degrees) + * are re-applied to the TPS camera every + * frame via PlayerControllerSystem; + * --screenshot N path write frame N of the render window to + * path (RenderWindow::writeContentsToFile) + * and quit. + * --debug-buoyancy enable BuoyancySystem debug logging (same + * as the editor's --debug-buoyancy). */ +struct DebugCaptureListener : public Ogre::FrameListener { + EditorApp *app; + bool teleportEnabled = false; + bool teleported = false; + Ogre::Vector3 teleportPos = Ogre::Vector3::ZERO; + float teleportYawDeg = 0.0f; + float teleportPitchDeg = 0.0f; + int shotFrame = -1; + Ogre::String shotFile; + int frame = 0; + + DebugCaptureListener(EditorApp *a) : app(a) {} + + bool frameRenderingQueued(const Ogre::FrameEvent &) override + { + frame++; + if (teleportEnabled) { + flecs::entity player = app->getPlayerCharacterEntity(); + if (player.is_alive() && + player.has()) { + TransformComponent &t = + player.get_mut(); + if (t.node) { + /* Re-teleport while the character is below + * the terrain surface at the target: the + * streaming terrain colliders may not be + * built yet on the first frames, so the + * character can fall through. Once the + * collider exists it stands (or floats in + * deep water) at/above the surface and the + * teleport stops. */ + bool fellThrough = false; + TerrainSystem *ts = + TerrainSystem::getInstance(); + if (teleported && ts && ts->isActive()) { + float ground = ts->getHeightAt( + teleportPos); + fellThrough = + t.node->getPosition().y < + ground - 0.5f; + } + if (!teleported || fellThrough) { + t.node->setPosition(teleportPos); + t.node->setOrientation(Ogre::Quaternion( + Ogre::Degree(teleportYawDeg), + Ogre::Vector3::UNIT_Y)); + teleported = true; + } + } + } + } + /* The TPS camera yaw lives in PlayerControllerSystem state, + * not in the character node orientation, so re-apply the + * requested yaw/pitch every frame once teleported. */ + if (teleported && app->getPlayerControllerSystem()) + app->getPlayerControllerSystem()->setControllerYawPitch( + teleportYawDeg, teleportPitchDeg); + if (shotFrame > 0 && frame >= shotFrame) { + app->getRenderWindow()->writeContentsToFile(shotFile); + app->getRoot()->queueEndRendering(); + } + return true; + } +}; + +/* Same application as the editor/game, but with a larger initial window. */ +class DemoApp : public EditorApp { +public: + using EditorApp::EditorApp; + + OgreBites::NativeWindowPair + createWindow(const Ogre::String &name, uint32_t w, uint32_t h, + Ogre::NameValuePairList miscParams) override + { + (void)w; + (void)h; + return EditorApp::createWindow(name, 1920, 1080, miscParams); + } +}; + +/* + * The demo floor mesh and its flat colored material are created + * programmatically because RenderableComponent only references a mesh by + * name and carries no material/color of its own. Only the interior scene + * needs one (the green "DemoFloorPlaneInterior"); the exterior scene + * walks on the terrain instead. + */ +static void createFloorMesh(const Ogre::String &meshName, + const Ogre::String &materialName, + float dr, float dg, float db) +{ + const Ogre::String group = + Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME; + + if (!Ogre::MeshManager::getSingleton() + .getByName(meshName, group) + .isNull()) + return; + + Ogre::MaterialPtr mat = Ogre::MaterialManager::getSingleton().create( + materialName, group); + Ogre::Pass *pass = mat->getTechnique(0)->getPass(0); + pass->setDiffuse(dr, dg, db, 1.0f); + pass->setAmbient(dr * 0.4f, dg * 0.4f, db * 0.4f); + pass->setSpecular(0.0f, 0.0f, 0.0f, 1.0f); + + /* 60 x 60 units, matching the 30 x 0.1 x 30 static box collider + * (top surface at y = 0) on the "demo_floor" entity in the scenes. */ + Ogre::Plane groundPlane(Ogre::Vector3::UNIT_Y, 0.0f); + Ogre::MeshPtr mesh = Ogre::MeshManager::getSingleton().createPlane( + meshName, group, groundPlane, 60.0f, 60.0f, 1, 1, true, 1, + 1.0f, 1.0f, Ogre::Vector3::UNIT_Z); + mesh->getSubMesh(0)->setMaterialName(materialName); +} + +static void createDemoResources() +{ + /* Interior scene: green floor. The exterior scene has no floor + * mesh — the terrain provides the ground. */ + createFloorMesh("DemoFloorPlaneInterior", "DemoFloorMaterialInterior", + 0.35f, 0.5f, 0.35f); +} + +/* + * End-to-end check for --test-switch: drives the same path an E-press on + * a scene-switch door takes (DoorComponent toggleRequested + + * sceneSwitchPending -> DoorSystem swing -> EditorApp::switchScene() + * queue once the leaf is fully open -> performSceneSwitch() on the next + * frame with the "@arrival_*" teleport), for a full + * interior -> exterior -> interior round trip: the interior scene exits + * through the "interrior" grid's door Z:0:0:15 and the exterior scene + * returns through its own grid's door Z:0:0:0. The prompt/targeting + * glue is screen-space and therefore not covered headless. + */ +struct SceneSwitchTestListener : public Ogre::FrameListener { + EditorApp *app; + int frame = 0; + int phase = 10; /* 10-12: F6 locked door, then 0-3 scene switching */ + bool failed = false; + Ogre::String failReason; + + /* F6 demo door: internal doorway Z:0:0:8 of the "interrior" grid, + * lockable + locked by default (doorConfigs in + * demo_scene_interior.json); the inline scene script unlocks it on + * the first door_locked bump. */ + const Ogre::String doorId = + "d6f6a1e2-4b5c-4d6e-8f70-a1b2c3d4e5f6:Z:0:0:8"; + + /* F1 demo doors: the interior scene exits through the external + * doorway Z:0:0:15 of the "interrior" grid (scene-switch door to + * demo_scene_exterior.json), the exterior scene returns through the + * external doorway Z:0:0:0 of its own exteriorOnly grid + * (scene-switch door back to demo_scene_interior.json). For both + * legs the switch must fire only when the leaf is fully open. */ + const Ogre::String exitDoorId = + "d6f6a1e2-4b5c-4d6e-8f70-a1b2c3d4e5f6:Z:0:0:15"; + const Ogre::String returnDoorId = + "77370b1d-e8ab-44a6-865b-e55c15b0fc78:Z:0:0:0"; + int exitOpenWait = 0; + int returnOpenWait = 0; + int arrivalDeadline = 0; + + /* arrival_b in the exterior scene: 3 units outside (-Z of) the + * exteriorOnly grid's return door Z:0:0:0 near the streaming-world + * center. The expected Y is the terrain surface height there, read + * back from the engine (streaming terrain: base heights come from + * baseNoise, so no flat Y can be hardcoded). */ + Ogre::Vector3 expectedArrivalB() const + { + Ogre::Vector3 expected(4000.6f, 0.0f, 3995.9f); + TerrainSystem *ts = TerrainSystem::getInstance(); + if (ts && ts->isActive()) + expected.y = ts->getHeightAt(ts->worldToRender( + expected.x, 0.0, expected.z)); + return expected; + } + + SceneSwitchTestListener(EditorApp *a) + : app(a) + { + } + + bool entityExists(const char *name) + { + bool found = false; + app->getWorld()->query().each( + [&](flecs::entity, EntityNameComponent &n) { + if (n.name == name) + found = true; + }); + return found; + } + + /* The F6 demo door entity (recreated on every scene load). */ + flecs::entity findDoor() + { + return findDoorById(doorId); + } + + flecs::entity findDoorById(const Ogre::String &id) + { + flecs::entity result = flecs::entity::null(); + app->getWorld()->query().each( + [&](flecs::entity e, DoorComponent &d) { + if (d.doorId == id) + result = e; + }); + return result; + } + + /* Emulate the E-press on a scene-switch door. */ + bool requestDoorSwitch(const Ogre::String &id) + { + flecs::entity door = findDoorById(id); + if (!door.is_alive()) + return false; + DoorComponent &d = door.get_mut(); + if (!d.occluder) { + failed = true; + failReason = "F1 scene-switch door has no occluder"; + return true; + } + d.toggleRequested = true; + d.sceneSwitchPending = true; + return true; + } + + /* Waits for the queued scene switch of a scene-switch door; + * returns true once the switch to expectPath is pending (the door + * must be fully open by then). */ + bool waitDoorSwitch(const Ogre::String &id, const Ogre::String &label, + const char *expectPath, int &openWait) + { + flecs::entity door = findDoorById(id); + if (!door.is_alive()) + return false; + const DoorComponent &d = door.get(); + bool fullyOpen = d.isOpen && d.currentAngle == d.openAngle; + if (app->hasPendingSceneSwitch()) { + if (!fullyOpen) { + failed = true; + failReason = + "F1 scene switch fired before the door was fully open"; + return true; + } + if (app->getPendingSceneSwitchPath() != expectPath) { + failed = true; + failReason = "F1 wrong pending switch path"; + return true; + } + std::cout << "[test] F1 " << label + << " fully open, switch queued" << std::endl; + return true; + } + if (fullyOpen) { + /* Frame-listener ordering grace. */ + if (++openWait > 5) { + failed = true; + failReason = "F1 scene switch never fired"; + } + } else { + openWait = 0; + } + return false; + } + + bool playerPos(Ogre::Vector3 &out) const + { + flecs::entity player = app->getPlayerCharacterEntity(); + if (!player.is_alive() || !player.has()) + return false; + + const TransformComponent &t = player.get(); + out = t.node ? t.node->_getDerivedPosition() : t.position; + return true; + } + + bool checkPlayerNear(const Ogre::Vector3 &expected, float tol) + { + Ogre::Vector3 pos; + if (!playerPos(pos)) + return false; + if (pos.distance(expected) > tol) { + failed = true; + failReason = "player not at arrival point: (" + + Ogre::StringConverter::toString(pos.x) + + ", " + + Ogre::StringConverter::toString(pos.y) + + ", " + + Ogre::StringConverter::toString(pos.z) + + ")"; + } + return true; + } + + /* The arrival markers face -Z (both scenes keep the same facing + * convention; the exterior arrival_b at (4000.6, ~, 3995.9) faces + * away from the return door); verify the camera took a position + * behind the character (relative to charPos) looking at the walking + * surface, and that the character's visual facing (local +Z) points + * the same way. */ + bool checkCameraFacesCenter(const Ogre::Vector3 &charPos) + { + flecs::entity player = app->getPlayerCharacterEntity(); + if (!player.is_alive() || !player.has()) + return false; + + const TransformComponent &t = player.get(); + Ogre::Quaternion q = + t.node ? t.node->getOrientation() : t.rotation; + Ogre::Vector3 charFacing = q * Ogre::Vector3::UNIT_Z; + + EditorCamera *ec = app->getEditorCamera(); + Ogre::Camera *cam = ec ? ec->getCamera() : nullptr; + Ogre::SceneNode *camNode = + cam ? cam->getParentSceneNode() : nullptr; + if (!camNode) + return false; + Ogre::Vector3 cp = camNode->_getDerivedPosition(); + Ogre::Vector3 vd = camNode->_getDerivedOrientation() * + Ogre::Vector3::NEGATIVE_UNIT_Z; + if (vd.z > -0.9f || cp.z < charPos.z + 1.0f || + charFacing.z > -0.9f) { + failed = true; + failReason = + "not facing the walking surface: camera pos (" + + Ogre::StringConverter::toString(cp.x) + ", " + + Ogre::StringConverter::toString(cp.y) + ", " + + Ogre::StringConverter::toString(cp.z) + + ") view (" + + Ogre::StringConverter::toString(vd.x) + ", " + + Ogre::StringConverter::toString(vd.y) + ", " + + Ogre::StringConverter::toString(vd.z) + + ") character facing (" + + Ogre::StringConverter::toString(charFacing.x) + + ", " + + Ogre::StringConverter::toString(charFacing.z) + + ")"; + } + return true; + } + + bool frameRenderingQueued(const Ogre::FrameEvent &) override + { + frame++; + if (failed || phase == 3) { + app->getRoot()->queueEndRendering(); + return true; + } + /* The swings are real-time (doorOpenSpeed deg/s) while a + * headless frame is sub-millisecond, so the door legs need a + * few thousand frames (~10 s wall clock at 1000+ fps); the + * streaming terrain window and the grounding watchdog add a + * few hundred frames on top. */ + if (frame > 20000) { + failed = true; + failReason = "timeout waiting for scene switch"; + app->getRoot()->queueEndRendering(); + return true; + } + + switch (phase) { + case 10: { + /* F6: the demo door starts locked (lockedByDefault). */ + if (frame < 5) + break; + flecs::entity door = findDoor(); + if (!door.is_alive()) { + if (frame > 60) { + failed = true; + failReason = "F6 demo door not found"; + } + break; + } + if (!DoorSystem::isDoorLockedById(doorId)) { + failed = true; + failReason = "F6 demo door not locked at start"; + break; + } + /* Emulate the ActuatorSystem E-press on a locked door; + * the inline scene script answers door_locked with + * door_unlock_. */ + EventBus::getInstance().send("door_locked", "door_id", + doorId); + phase = 11; + break; + } + case 11: { + /* F6: wait for the scene script to unlock the door + * (the frame timeout covers a missing handler). */ + if (DoorSystem::isDoorLockedById(doorId)) + break; + flecs::entity door = findDoor(); + if (!door.is_alive()) + break; + door.get_mut().toggleRequested = true; + std::cout << "[test] F6 door unlocked via scene script, " + "opening" + << std::endl; + phase = 12; + break; + } + case 12: { + /* F6: the swing completes and the open state lands in + * the global store. */ + flecs::entity door = findDoor(); + if (!door.is_alive()) + break; + const DoorComponent &d = door.get(); + if (!d.isOpen || d.currentAngle != d.openAngle) + break; + if (!GlobalStateStore::getInstance().getBool( + "door." + doorId + ".isOpen")) { + failed = true; + failReason = "F6 door open state not persisted"; + break; + } + std::cout << "[test] F6 door open and persisted" + << std::endl; + phase = 0; + break; + } + case 0: { + /* F1: interior -> exterior through the exit scene-switch + * door. */ + if (frame < 5) + break; + if (!findDoorById(exitDoorId).is_alive()) { + if (frame > 60) { + failed = true; + failReason = "F1 exit door not found"; + } + break; + } + /* F1: every scene-switch door gets the void-side + * tunnel occluder (depth covers the leaf sweep, + * so both swing directions stay visible) plus the + * gap shield backing the leaf/frame clearance + * slits while the door is closed. */ + { + const DoorComponent &d = + findDoorById(exitDoorId) + .get(); + if (!d.occluder || + d.occluder->getMesh() + ->getName() + .find("CellGridDoorOccluderTunnel") != + 0) { + failed = true; + failReason = + "F1 exit door has no tunnel occluder"; + break; + } + if (!d.gapShield || + d.gapShield->getMesh() + ->getName() + .find("CellGridDoorOccluderShield") != + 0) { + failed = true; + failReason = + "F1 exit door has no gap shield"; + break; + } + /* The door is still closed here: the shield + * backs the slits, the tunnel stays hidden. */ + if (!d.gapShield->isVisible() || + d.occluder->isVisible()) { + failed = true; + failReason = + "F1 closed-door occluder visibility wrong"; + break; + } + /* The tunnel walls must reach past the + * leaf/frame clearances (0.02 m sides, + * 0.05 m top) or the void shows between the + * frame and the black corridor while the + * door is open; both meshes are hinge-local, + * so the tunnel footprint must cover at + * least the gap shield's (6 cm margin). */ + { + Ogre::Vector3 th = + d.occluder->getMesh() + ->getBounds() + .getHalfSize(); + Ogre::Vector3 sh = + d.gapShield->getMesh() + ->getBounds() + .getHalfSize(); + if (th.x < sh.x - 0.001f || + th.y < sh.y - 0.001f) { + failed = true; + failReason = + "F1 tunnel walls inside the leaf/frame clearances"; + break; + } + } + } + if (!requestDoorSwitch(exitDoorId)) + break; + phase = 13; + break; + } + case 13: { + /* F1: the scene switch must fire only once the leaf + * is fully open. */ + if (waitDoorSwitch(exitDoorId, "exit door", + "demo_scene_exterior.json", + exitOpenWait)) + phase = 1; + break; + } + case 1: { + if (!entityExists("x1")) + break; + if (!arrivalDeadline) + arrivalDeadline = frame + 600; + /* The teleport clamps Y against whatever height source is + * available at switch time (analytic baseNoise fallback + * until the pages around the camera stream in), then the + * grounding watchdog re-clamps against the real terrain + * for ~120 frames; poll across frames until the player + * settles at the arrival point instead of checking once. */ + Ogre::Vector3 expected = expectedArrivalB(); + Ogre::Vector3 pos; + if (!playerPos(pos)) + break; + if (pos.distance(expected) > 1.0f) { + if (frame < arrivalDeadline) + break; + failed = true; + failReason = + "player not at arrival point: (" + + Ogre::StringConverter::toString(pos.x) + + ", " + + Ogre::StringConverter::toString(pos.y) + + ", " + + Ogre::StringConverter::toString(pos.z) + + "), expected (" + + Ogre::StringConverter::toString( + expected.x) + + ", " + + Ogre::StringConverter::toString( + expected.y) + + ", " + + Ogre::StringConverter::toString( + expected.z) + + ")"; + break; + } + if (!checkCameraFacesCenter(expected)) + break; + if (failed) + break; + /* The island site must be dry: terrain height at the + * grid XZ above the water surface (Y 6). Doubles as an + * in-engine cross-check of the offline baseNoise mapping + * used to place the exterior content. */ + { + TerrainSystem *ts = TerrainSystem::getInstance(); + float h = ts && ts->isActive() + ? ts->getHeightAt( + ts->worldToRender(4000.0, + 0.0, + 4000.0)) + : 0.0f; + if (h <= 6.0f) { + failed = true; + failReason = + "island site is not dry"; + break; + } + } + std::cout << "[test] arrived in the exterior scene at " + "arrival_b, camera faces the walking surface" + << std::endl; + /* F1: exterior -> interior through the exterior + * scene's own scene-switch door (external doorway + * Z:0:0:0 of its exteriorOnly grid). */ + if (!findDoorById(returnDoorId).is_alive()) { + failed = true; + failReason = "F1 return door not found"; + break; + } + if (!requestDoorSwitch(returnDoorId)) + break; + phase = 14; + break; + } + case 14: + /* F1: same fully-open contract on the way back. */ + if (waitDoorSwitch(returnDoorId, "return door", + "demo_scene_interior.json", + returnOpenWait)) + phase = 2; + break; + case 2: + if (!entityExists("interrior")) + break; + if (!checkPlayerNear(Ogre::Vector3(0.0f, 0.0f, 24.0f), + 1.0f)) + break; + if (!checkCameraFacesCenter(Ogre::Vector3(0.0f, 0.0f, + 24.0f))) + break; + /* F6: the door rebuilt with the scene must be snapped + * back to the persisted open + unlocked state. */ + { + flecs::entity door = findDoor(); + if (!door.is_alive()) + break; + const DoorComponent &d = + door.get(); + if (!d.isOpen || d.currentAngle != d.openAngle || + DoorSystem::isDoorLockedById(doorId)) { + failed = true; + failReason = + "F6 door state not restored after scene switch"; + break; + } + std::cout << "[test] F6 door state restored " + "after scene switch" + << std::endl; + } + /* F1: the scene-switch exit door rebuilt with the + * scene must be closed again - scene-switch doors + * never restore the persisted open state. */ + { + flecs::entity exitDoor = + findDoorById(exitDoorId); + if (!exitDoor.is_alive()) + break; + const DoorComponent &d = + exitDoor.get(); + if (d.isOpen || d.currentAngle != 0.0f || + GlobalStateStore::getInstance().getBool( + "door." + exitDoorId + ".isOpen")) { + failed = true; + failReason = + "F1 exit door not closed after scene switch"; + break; + } + std::cout << "[test] F1 exit door closed after " + "scene switch" + << std::endl; + } + if (!failed) { + std::cout << "[test] arrived back in the interior " + "scene at arrival_a, camera faces the " + "walking surface" + << std::endl; + std::cout << "[test] PASS" << std::endl; + } + phase = 3; + break; + } + return true; + } +}; + +/* + * demo-taxi: taxi driver demo. Starts as an exact copy of + * demos/demo-interior-exterior-dynamics (same scene-switch-door setup, + * same streaming-terrain/sky/water exterior); the taxi game (procedural + * town, drivable sedans, passenger/foot-traffic/vehicle-traffic NPCs, + * chained fares) is added step by step - see PLAN.md in this directory. + * Vehicle ideas come from demos/demo-sokoban. + * + * Base description inherited from demo-interior-exterior-dynamics: + * same scene-switching demo as + * demos/demo-scene-switching-extra, but the exterior scene is a real + * outdoor environment instead of a flat colored floor. Two + * hand-authored scenes (demo_scene_interior.json and + * demo_scene_exterior.json), each with a character spawner ("s1", + * character registry ID 2, same character setup as town8.json) and a + * PlayerControllerComponent targeting it. + * + * The interior scene holds a flat colored floor plane with a static + * physics collider plus an "interrior" entity with a CellGridComponent + * in interiorOnly generation mode (a room with floor, ceiling, interior + * walls, windows with opaque glass and an exit door) carrying its own + * ProceduralMaterial + ProceduralTexture; the grid's texture rectangle + * names reference the texture's named rects ("floor" / "ceiling") + * without any Lot/District/Town parent. + * + * The exterior scene holds an exteriorOnly CellGridComponent (entity + * "x1"/"w1" - just the building shell with opaque window glass, seen + * from the outside) standing on a STREAMING terrain entity + * (streamingEnabled, worldSizeUnits 10000 -> 5x5 pages of 2000 units, + * base heights from TerrainComponent::baseNoise: OpenSimplex2 seed 55, + * 3 octaves, frequency 0.0003, amplitude 15 - an archipelago of large + * islands, ~34% land, the rest is ocean). The bounded streaming world + * spans [-1000, 9000] on both axes around the terrain entity at the + * origin (world (0,0) is half a page in from the corner, NOT the world + * center), so all exterior content is placed near the world center on + * an island with more than 500 units of dry land in every direction: + * the grid at (4000, 10.0148, 4000) with its floor exactly on the + * terrain surface, arrival_b at (4000.6, 9.9905, 3995.9) 3 units + * outside (-Z of) the return door Z:0:0:0, spawner s1 at (4000, + * 9.9039, 3975) - all Y values probed from the engine's + * TerrainSystem::getHeightAt. The "sky" entity (skybox + sun + * components) sits at (4000, 10, 4000): EditorSunSystem parents the + * sun/moon sphere nodes to the root node and orbits them around the + * camera (orbit radius 200), so they always stay inside the + * camera-following skybox cube and line up with the shader sun/moon + * discs, but the light node stays a child of the sky entity's + * transform node, so the entity should still sit near the content for + * sensible shadow placement (town8.json keeps its sky entity at the + * origin next to its content). A "water" + * entity (waterPlane + waterPhysics components, the buoyancy setup of + * town8.json, planeSize 12000 centered on the content) completes the + * scene; the water surface at Y 6 turns everything below into ocean + * floor while the content island (terrain ~10 at the site) stays dry. + * The shipped heightmaps/4242424300000001/heightmap.bin (generated by + * gen_heightmap.py) is still staged - unused in streaming mode, it keeps + * flipping streamingEnabled off a working fallback. + * + * F6 demo content: the interior grid's internal doorway Z:0:0:8 is + * configured (doorConfigs in demo_scene_interior.json) as persistent + + * lockable + locked by default, with a fixed gridUid so its global door + * ID is stable, and the grid entity carries an inline scene script that + * answers the "door_locked" event with "door_unlock_" (the door + * event contract; the door never opens by itself, the player presses E + * again). The door's locked and open/closed state lives in the global + * state store and survives the interior -> exterior -> interior scene + * switches. + * + * F1 demo content: both scene transitions go through scene-switch doors. + * The interior grid has the external exit doorway Z:0:0:15 configured as + * a scene-switch door to demo_scene_exterior.json (target arrival_b); + * the exterior grid sets + * doorSceneSwitchPath/demo_scene_interior.json + + * doorSceneSwitchTarget/arrival_a grid-wide, so its external doorway + * Z:0:0:0 is the way back. E on such a door swings the leaf open first; + * the scene switch fires only when the leaf reaches the open angle, and + * a black occluder box behind the doorway hides the missing half of the + * building while it swings; while the door is closed a flat black gap + * shield behind the leaf blacks out the leaf/frame clearance slits, so + * no sky/terrain bleeds through the closed door. Both scenes carry + * their own player + * controller, so each switch is a clean takeover (see + * EditorApp::performSceneSwitch); travel back and forth is endless. + * + * The mouse is grabbed while Playing (built-in game-mode behaviour); + * Escape toggles the pause menu, which frees the cursor. + * + * The binary is self-contained in its build directory: run it from there + * (resources.cfg, resources/, characters/, lua-scripts/, prefabs/ and the + * runtime config JSONs are staged next to it by the build; both scene + * JSONs are symlinks into the source tree, so scene edits take effect + * without a rebuild; the terrain heightmap is staged to + * heightmaps/4242424300000001/ by configure_file, re-copied automatically + * when the source file changes). + * + * Extra flags: + * --test-switch headless-friendly end-to-end check: verifies the F6 + * locked door (locked at start, unlocked by the scene + * script through the door event contract, open state + * persisted and restored across the scene switches) and + * both F1 scene-switch doors (interior -> exterior and + * back each fire only when the leaf is fully open, + * black occluder tunnel + closed-door gap shield + * present with the right closed-state visibility), + * verifying the round-trip + * arrival teleports (the exterior arrival check reads + * the expected Y from TerrainSystem::getHeightAt and + * polls while the streaming window loads and the + * grounding watchdog re-clamps); exits 0 on PASS. + */ +int main(int argc, char *argv[]) +{ + try { +#ifdef EDITSCENE_HAS_EMBEDDED_PROJECT + /* Release binary: project parameters are embedded at build + * time from project.json (generated project.h); the project + * root is the working directory the binary runs from. */ + DemoApp app(EDITSCENE_PROJECT_APP_NAME); + { + ProjectConfig cfg; + cfg.rootDir = + std::filesystem::current_path().string(); + cfg.appName = EDITSCENE_PROJECT_APP_NAME; + cfg.startScene = EDITSCENE_PROJECT_START_SCENE; + cfg.gameMode = EDITSCENE_PROJECT_GAME_MODE; + cfg.loaded = true; + app.setProjectConfig(cfg); + } +#else + DemoApp app; +#endif + app.setGameMode(EditorApp::GameMode::Game); + + bool headless = false; + bool exitAfterFirstFrame = false; + bool testSwitch = false; + bool sceneArgGiven = false; + Ogre::String shotFile; + int shotFrame = -1; + bool forcePos = false; + Ogre::Vector3 forcePosVec = Ogre::Vector3::ZERO; + float forcePosYaw = 0.0f; + float forcePosPitch = 0.0f; +#ifdef EDITSCENE_HAS_EMBEDDED_PROJECT + Ogre::String sceneFile = EDITSCENE_PROJECT_START_SCENE; +#else + Ogre::String sceneFile = "demo_scene_interior.json"; +#endif + for (int i = 1; i < argc; i++) { + Ogre::String arg = argv[i]; + if (arg == "--headless") { + headless = true; + } else if (arg == "--exit-after-first-frame") { + exitAfterFirstFrame = true; + } else if (arg == "--test-switch") { + testSwitch = true; + } else if (arg == "--debug-buoyancy") { + app.setDebugBuoyancy(true); + } else if (arg == "--screenshot" && i + 2 < argc) { + shotFrame = atoi(argv[i + 1]); + shotFile = argv[i + 2]; + i += 2; + } else if (arg == "--force-pos" && i + 4 < argc) { + forcePos = true; + forcePosVec = Ogre::Vector3( + (float)atof(argv[i + 1]), + (float)atof(argv[i + 2]), + (float)atof(argv[i + 3])); + forcePosYaw = (float)atof(argv[i + 4]); + i += 4; + /* Optional pitch (degrees); only consumed when + * the next token is plainly numeric, so the + * positional scene file is never eaten. */ + if (i + 1 < argc) { + char *end = nullptr; + float p = (float)strtod(argv[i + 1], + &end); + if (end && *end == '\0' && + end != argv[i + 1]) { + forcePosPitch = p; + i += 1; + } + } + } else if (arg.length() > 0 && arg[0] != '-') { + sceneFile = arg; + sceneArgGiven = true; + } + } + app.setHeadless(headless); + + app.initApp(); + + if (headless) { + /* Headless mode never creates EditorUISystem, which + * owns the CharacterRegistry singleton; the demo scene + * has a character spawner, so provide a bare registry + * to keep spawner resolution from asserting. The + * character then falls back to an inline spawn without + * a physics capsule (fine for a smoke run). */ + static CharacterRegistry s_characterRegistry; + s_characterRegistry.setWorld(app.getWorld()); + s_characterRegistry.setSceneManager(app.getSceneManager()); + s_characterRegistry.initialize(); + } + + /* Meshes + materials referenced by the scene entities. */ + createDemoResources(); + + /* With an embedded project, EditorApp::setup() skipped the + * startup menu; the start scene defaults to the embedded + * one and can still be overridden positionally. */ + (void)sceneArgGiven; + std::cout << "[demo] starting new game with scene: " + << sceneFile << std::endl; + app.startNewGame(sceneFile); + std::cout << "[demo] controls: mouse = look, W/A/S/D = move, " + "Shift = run, E = use door, Escape = pause menu" + << std::endl; + + ExitAfterFirstFrameListener exitListener(app.getRoot()); + if (exitAfterFirstFrame && !testSwitch) + app.getRoot()->addFrameListener(&exitListener); + + SceneSwitchTestListener testListener(&app); + if (testSwitch) + app.getRoot()->addFrameListener(&testListener); + + DebugCaptureListener captureListener(&app); + if (forcePos) { + captureListener.teleportEnabled = true; + captureListener.teleportPos = forcePosVec; + captureListener.teleportYawDeg = forcePosYaw; + captureListener.teleportPitchDeg = forcePosPitch; + } + if (shotFrame > 0 && !shotFile.empty()) + captureListener.shotFrame = shotFrame; + captureListener.shotFile = shotFile; + if (forcePos || captureListener.shotFrame > 0) + app.getRoot()->addFrameListener(&captureListener); + + app.getRoot()->startRendering(); + + if (testSwitch) { + if (testListener.failed) { + std::cerr << "[test] FAIL: " + << testListener.failReason + << std::endl; + app.clearScene(); + app.closeApp(); + return 1; + } + if (testListener.phase != 3) { + std::cerr << "[test] FAIL: incomplete" + << std::endl; + app.clearScene(); + app.closeApp(); + return 1; + } + } + + /* Destroy scene entities while the systems are still alive: + * CharacterSpawnerSystem registers an OnRemove observer on + * CharacterSpawnerComponent that dereferences the system, and + * the flecs world only dies after destroyEditorSystems() in + * ~EditorApp, so letting the spawner entity live that long + * would call back into a destroyed system. */ + app.clearScene(); + app.closeApp(); + } catch (const std::exception &e) { + std::cerr << "Error: " << e.what() << std::endl; + return 1; + } + + return 0; +} diff --git a/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json b/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json new file mode 100644 index 0000000..a12a292 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/demo_scene_exterior.json @@ -0,0 +1,771 @@ +{ + "actionDatabase": { + "actions": [ + { + "behaviorTree": { + "children": [ + { + "name": "luaHello", + "params": "message=Welcome to the game!", + "type": "luaTask" + }, + { + "name": "main/action", + "type": "setAnimationState" + }, + { + "name": "action/sitting-ground", + "type": "setAnimationState" + }, + { + "name": "dly", + "params": "9.0", + "type": "delay" + }, + { + "name": "main/locomotion", + "type": "setAnimationState" + }, + { + "name": "locomotion/idle", + "type": "setAnimationState" + } + ], + "type": "sequence" + }, + "cost": 1, + "effects": { + "bits": 0, + "mask": 0 + }, + "name": "lua_hello_action", + "preconditions": { + "bits": 0, + "mask": 0 + } + }, + { + "behaviorTree": { + "children": [ + { + "name": "main/action", + "type": "setAnimationState" + }, + { + "name": "action/sitting-ground", + "type": "setAnimationState" + }, + { + "name": "dly", + "params": "6.0", + "type": "delay" + }, + { + "name": "main/locomotion", + "type": "setAnimationState" + }, + { + "name": "locomotion/idle", + "type": "setAnimationState" + }, + { + "name": "luaHello", + "params": "message=\"hello, world!\"", + "type": "luaTask" + } + ], + "type": "sequence" + }, + "cost": 1, + "effects": { + "bits": 0, + "mask": 0 + }, + "name": "testAction", + "preconditions": { + "bits": 0, + "mask": 0 + } + } + ], + "bitNames": [ + { + "index": 1, + "name": "hungry" + }, + { + "index": 2, + "name": "thirsty" + } + ], + "goals": [] + }, + "bookmarks": [], + "entities": [ + { + "children": [], + "id": 488, + "name": { + "name": "arrival_b" + }, + "transform": { + "position": { + "x": 4000.60009765625, + "y": 9.990500450134277, + "z": 3995.89990234375 + }, + "rotation": { + "w": 0.0, + "x": 0.0, + "y": 1.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [ + { + "cellGrid": { + "ceilingRectName": "", + "cellHeight": 4.0, + "cellSize": 2.0, + "cells": [ + { + "flags": 37757955, + "x": -1, + "y": 0, + "z": 0 + }, + { + "flags": 2097667, + "x": 0, + "y": 0, + "z": 0 + }, + { + "flags": 41953283, + "x": 1, + "y": 0, + "z": 0 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 1 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 1 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 1 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 2 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 2 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 2 + }, + { + "flags": 20976643, + "x": -1, + "y": 0, + "z": 3 + }, + { + "flags": 16781315, + "x": 0, + "y": 0, + "z": 3 + }, + { + "flags": 25171971, + "x": 1, + "y": 0, + "z": 3 + } + ], + "depth": 10, + "doorActionName": "", + "doorConfigs": {}, + "doorMeshName": "", + "doorOpenAngle": 100.0, + "doorOpenSpeed": 180.0, + "doorRectName": "", + "doorSceneSwitchPath": "demo_scene_interior.json", + "doorSceneSwitchTarget": "arrival_a", + "doorSwingReversed": false, + "doorUseMeshMaterial": false, + "doorsEnabled": true, + "extDoorFrameRectName": "", + "extWallRectName": "", + "extWindowFrameRectName": "", + "floorRectName": "", + "friction": 0.5, + "furnitureCells": [], + "generationMode": "exteriorOnly", + "generationScript": "", + "glassColor": [ + 0.4000000059604645, + 0.6000000238418579, + 0.800000011920929, + 0.3499999940395355 + ], + "glassMaterialName": "", + "glassReflectivity": 0.800000011920929, + "gridUid": "77370b1d-e8ab-44a6-865b-e55c15b0fc78", + "height": 1, + "intDoorFrameRectName": "", + "intWallRectName": "", + "intWindowFrameRectName": "", + "roofSideRectName": "", + "roofTopRectName": "", + "width": 10 + }, + "children": [ + { + "children": [], + "clearArea": { + "clearCells": true, + "clearFurniture": true, + "clearRoofs": false, + "clearRooms": false, + "maxX": 10, + "maxY": 1, + "maxZ": 10, + "minX": -10, + "minY": 0, + "minZ": -10 + }, + "id": 491, + "name": { + "name": "c1" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 492, + "name": { + "name": "r1" + }, + "room": { + "connectedRoomIds": [], + "createCeiling": true, + "createFloor": true, + "createInteriorWalls": true, + "createWindows": true, + "exits": [ + true, + false, + false, + false + ], + "fillRoomWithFurniture": false, + "furnitureSeed": 42, + "furnitureYOffset": 0.05000000074505806, + "maxX": 2, + "maxY": 1, + "maxZ": 4, + "minX": -1, + "minY": 0, + "minZ": 0, + "persistentId": "room_1788689581735260047_499", + "roomType": "", + "tags": [] + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + } + ], + "id": 490, + "name": { + "name": "w1" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + } + ], + "id": 489, + "name": { + "name": "x1" + }, + "transform": { + "position": { + "x": 4000.0, + "y": 10.014800071716309, + "z": 4000.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 493, + "light": { + "castShadows": false, + "constantAttenuation": 1.0, + "diffuseColor": { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + "direction": { + "x": 0.30000001192092896, + "y": -1.0, + "z": 0.20000000298023224 + }, + "intensity": 1.0, + "lightType": "directional", + "linearAttenuation": 0.0, + "quadraticAttenuation": 0.0, + "range": 100.0, + "specularColor": { + "a": 1.0, + "b": 0.5, + "g": 0.5, + "r": 0.5 + }, + "spotlightFalloff": 1.0, + "spotlightInnerAngle": 30.0, + "spotlightOuterAngle": 45.0 + }, + "name": { + "name": "demo_light" + }, + "transform": { + "position": { + "x": 4000.0, + "y": 20.0, + "z": 4000.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "characterSpawner": { + "despawnDistance": 200.0, + "registryId": 2, + "spawnDistance": 100.0 + }, + "children": [], + "id": 494, + "name": { + "name": "s1" + }, + "transform": { + "position": { + "x": 4000.0, + "y": 9.903900146484375, + "z": 3975.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 495, + "name": { + "name": "player" + }, + "playerController": { + "actuatorColor": [ + 0.0, + 0.4000000059604645, + 1.0 + ], + "actuatorCooldown": 1.5, + "actuatorDistance": 25.0, + "actuatorLabelFontSize": 12.0, + "cameraMode": 0, + "distantCircleRadius": 8.0, + "fpsBoneName": "Head", + "idleState": "idle", + "locomotionStateMachine": "locomotion", + "mouseSensitivity": 0.20000000298023224, + "nearCircleRadius": 14.0, + "runState": "running", + "swimFastState": "swimming-fast", + "swimIdleState": "swim-idle", + "swimState": "swimming", + "targetCharacterName": "s1", + "tpsDistance": 3.0, + "tpsHeight": 2.0, + "walkState": "walking" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 496, + "name": { + "name": "terrain" + }, + "terrain": { + "auxMaps": [], + "baseNoise": { + "amplitude": 15.0, + "frequency": 0.0003000000142492354, + "lacunarity": 2.0, + "octaves": 3, + "persistence": 0.5, + "seed": 55 + }, + "blendMapSize": 1024, + "compositeMapDistance": 300.0, + "detailNoise": { + "amplitude": 10.0, + "enabled": false, + "frequency": 0.006000000052154064, + "lacunarity": 2.0, + "octaves": 4, + "persistence": 0.5, + "seed": 26368 + }, + "enabled": true, + "farClipDistance": 6000.0, + "fogEnabled": true, + "fogEnd": 5500.0, + "fogStart": 2500.0, + "heightmapFile": "heightmap.bin", + "heightmapSize": 256, + "layers": [ + { + "diffuseTexture": "Ground23_col.jpg", + "name": "Base", + "normalTexture": "Ground23_normheight.dds", + "worldSize": 100.0 + }, + { + "diffuseTexture": "Ground37_diffspec.dds", + "name": "Layer 1", + "normalTexture": "Ground37_normheight.dds", + "worldSize": 100.0 + } + ], + "maxBatchSize": 65, + "maxPixelError": 1.0, + "minBatchSize": 17, + "pageHoldRadius": 3, + "pageLoadRadius": 2, + "roadConfig": { + "laneWidth": 3.0, + "lanesPerDirection": 1, + "prefabDespawnDistance": 250.0, + "prefabSpawnDistance": 150.0, + "roadLodDistance": 200.0, + "roadMaterialName": "RoadMaterial", + "roadMeshTemplate": "road_segment.mesh", + "roadThickness": 0.30000001192092896, + "roadVisibilityDistance": 1000.0, + "sidewalkEnabled": false, + "sidewalkHeight": 0.15000000596046448, + "sidewalkMeshTemplate": "", + "sidewalkThickness": 0.30000001192092896, + "sidewalkWidth": 1.5 + }, + "streamingEnabled": true, + "terrainId": 4242424300000001, + "terrainSize": 65, + "worldSize": 2000.0, + "worldSizeUnits": 10000.0 + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 497, + "name": { + "name": "sky" + }, + "skybox": { + "cloudiness": 0.0, + "dayBottomColor": [ + 0.6000000238418579, + 0.800000011920929, + 1.0 + ], + "dayTopColor": [ + 0.20000000298023224, + 0.5, + 1.0 + ], + "enabled": true, + "moonSize": 0.029999999329447746, + "nightBottomColor": [ + 0.05000000074505806, + 0.05000000074505806, + 0.15000000596046448 + ], + "nightTopColor": [ + 0.0, + 0.0, + 0.05000000074505806 + ], + "size": 443.0, + "starsEnabled": false, + "sunSize": 0.05000000074505806, + "sunriseColor": [ + 1.0, + 0.5, + 0.20000000298023224 + ], + "sunsetColor": [ + 1.0, + 0.30000001192092896, + 0.10000000149011612 + ] + }, + "sun": { + "ambientDay": [ + 0.30000001192092896, + 0.30000001192092896, + 0.30000001192092896 + ], + "ambientNight": [ + 0.05000000074505806, + 0.05000000074505806, + 0.15000000596046448 + ], + "ambientSunrise": [ + 0.30000001192092896, + 0.20000000298023224, + 0.15000000596046448 + ], + "ambientSunset": [ + 0.25, + 0.15000000596046448, + 0.10000000149011612 + ], + "castShadows": true, + "enabled": true, + "intensity": 1.7899999618530273, + "moonColor": [ + 0.30000001192092896, + 0.30000001192092896, + 0.5 + ], + "moonSphereSize": 3.4000000953674316, + "orbitTilt": 15.0, + "showMoonSphere": true, + "showSunSphere": true, + "sunColor": [ + 1.0, + 0.949999988079071, + 0.800000011920929 + ], + "sunSphereSize": 5.0, + "timeOfDay": 8.35942554473877, + "timeSpeed": 0.12999999523162842 + }, + "transform": { + "position": { + "x": 4000.0, + "y": 10.0, + "z": 4000.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 498, + "name": { + "name": "water" + }, + "transform": { + "position": { + "x": 4000.0, + "y": 0.0, + "z": 4000.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + }, + "waterPhysics": { + "defaultAngularDrag": 0.05000000074505806, + "defaultBuoyancy": 1.0, + "defaultLinearDrag": 0.25, + "defaultSubmergedThreshold": 0.10000000149011612, + "enabled": true, + "gravity": 9.8100004196167, + "waterDensity": 1000.0, + "waterSurfaceY": 6.0 + }, + "waterPlane": { + "autoUpdateFromWaterPhysics": true, + "enabled": true, + "planeSize": 12000.0, + "reflectivity": 0.3799999952316284, + "renderTextureSize": 512, + "tiling": 0.012000000104308128, + "waterColor": [ + 0.0, + 0.30000001192092896, + 0.5, + 0.800000011920929 + ], + "waterSurfaceY": 6.0, + "waveScale": 0.03099999949336052, + "waveSpeed": 0.9800000190734863 + } + } + ], + "version": "1.0" +} \ No newline at end of file diff --git a/src/features/editScene/demos/demo-taxi/demo_scene_interior.json b/src/features/editScene/demos/demo-taxi/demo_scene_interior.json new file mode 100644 index 0000000..3621489 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/demo_scene_interior.json @@ -0,0 +1,1522 @@ +{ + "actionDatabase": { + "actions": [ + { + "behaviorTree": { + "children": [ + { + "name": "luaHello", + "params": "message=Welcome to the game!", + "type": "luaTask" + }, + { + "name": "main/action", + "type": "setAnimationState" + }, + { + "name": "action/sitting-ground", + "type": "setAnimationState" + }, + { + "name": "dly", + "params": "9.0", + "type": "delay" + }, + { + "name": "main/locomotion", + "type": "setAnimationState" + }, + { + "name": "locomotion/idle", + "type": "setAnimationState" + } + ], + "type": "sequence" + }, + "cost": 1, + "effects": { + "bits": 0, + "mask": 0 + }, + "name": "lua_hello_action", + "preconditions": { + "bits": 0, + "mask": 0 + } + }, + { + "behaviorTree": { + "children": [ + { + "name": "main/action", + "type": "setAnimationState" + }, + { + "name": "action/sitting-ground", + "type": "setAnimationState" + }, + { + "name": "dly", + "params": "6.0", + "type": "delay" + }, + { + "name": "main/locomotion", + "type": "setAnimationState" + }, + { + "name": "locomotion/idle", + "type": "setAnimationState" + }, + { + "name": "luaHello", + "params": "message=\"hello, world!\"", + "type": "luaTask" + } + ], + "type": "sequence" + }, + "cost": 1, + "effects": { + "bits": 0, + "mask": 0 + }, + "name": "testAction", + "preconditions": { + "bits": 0, + "mask": 0 + } + } + ], + "bitNames": [ + { + "index": 1, + "name": "hungry" + }, + { + "index": 2, + "name": "thirsty" + } + ], + "goals": [] + }, + "bookmarks": [], + "entities": [ + { + "children": [], + "id": 4294967793, + "name": { + "name": "arrival_a" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 24.0 + }, + "rotation": { + "w": 0.0, + "x": 0.0, + "y": 1.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 4294967794, + "light": { + "castShadows": false, + "constantAttenuation": 1.0, + "diffuseColor": { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + "direction": { + "x": 0.30000001192092896, + "y": -1.0, + "z": 0.20000000298023224 + }, + "intensity": 1.0, + "lightType": "directional", + "linearAttenuation": 0.0, + "quadraticAttenuation": 0.0, + "range": 100.0, + "specularColor": { + "a": 1.0, + "b": 0.5, + "g": 0.5, + "r": 0.5 + }, + "spotlightFalloff": 1.0, + "spotlightInnerAngle": 30.0, + "spotlightOuterAngle": 45.0 + }, + "name": { + "name": "demo_light" + }, + "transform": { + "position": { + "x": 0.0, + "y": 10.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "collider": { + "halfHeight": 1.0, + "meshName": "", + "offset": { + "x": 0.0, + "y": -0.10000000149011612, + "z": 0.0 + }, + "parameters": { + "x": 30.0, + "y": 0.10000000149011612, + "z": 30.0 + }, + "radius": 0.5, + "rotationOffset": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "shapeType": "box" + }, + "id": 4294967792, + "name": { + "name": "demo_floor" + }, + "renderable": { + "meshName": "DemoFloorPlaneInterior", + "visible": true + }, + "rigidBody": { + "bodyType": "static", + "enabled": true, + "friction": 0.800000011920929, + "isSensor": false, + "mass": 1.0, + "restitution": 0.0 + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "characterSpawner": { + "despawnDistance": 200.0, + "registryId": 2, + "spawnDistance": 100.0 + }, + "children": [], + "id": 4294967790, + "name": { + "name": "s1" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.10288965702056885, + "z": -3.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 4294967789, + "name": { + "name": "player" + }, + "playerController": { + "actuatorColor": [ + 0.0, + 0.4000000059604645, + 1.0 + ], + "actuatorCooldown": 1.5, + "actuatorDistance": 25.0, + "actuatorLabelFontSize": 12.0, + "cameraMode": 0, + "distantCircleRadius": 8.0, + "fpsBoneName": "Head", + "idleState": "idle", + "locomotionStateMachine": "locomotion", + "mouseSensitivity": 0.20000000298023224, + "nearCircleRadius": 14.0, + "runState": "running", + "swimFastState": "swimming-fast", + "swimIdleState": "swim-idle", + "swimState": "swimming", + "targetCharacterName": "s1", + "tpsDistance": 3.0, + "tpsHeight": 2.0, + "walkState": "walking" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "cellGrid": { + "ceilingRectName": "ceiling", + "cellHeight": 4.0, + "cellSize": 2.0, + "cells": [ + { + "flags": 147495, + "x": -1, + "y": 0, + "z": -2 + }, + { + "flags": 131107, + "x": 0, + "y": 0, + "z": -2 + }, + { + "flags": 163883, + "x": 1, + "y": 0, + "z": -2 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": -1 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": -1 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": -1 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 0 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 0 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 0 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 1 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 1 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 1 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 2 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 2 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 2 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 3 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 3 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 3 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 4 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 4 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 4 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 5 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 5 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 5 + }, + { + "flags": 16391, + "x": -1, + "y": 0, + "z": 6 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 6 + }, + { + "flags": 32779, + "x": 1, + "y": 0, + "z": 6 + }, + { + "flags": 81927, + "x": -1, + "y": 0, + "z": 7 + }, + { + "flags": 1048579, + "x": 0, + "y": 0, + "z": 7 + }, + { + "flags": 98315, + "x": 1, + "y": 0, + "z": 7 + }, + { + "flags": 4326403, + "x": -1, + "y": 0, + "z": 8 + }, + { + "flags": 2097155, + "x": 0, + "y": 0, + "z": 8 + }, + { + "flags": 8521731, + "x": 1, + "y": 0, + "z": 8 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 9 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 9 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 9 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 10 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 10 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 10 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 11 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 11 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 11 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 12 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 12 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 12 + }, + { + "flags": 4195331, + "x": -1, + "y": 0, + "z": 13 + }, + { + "flags": 3, + "x": 0, + "y": 0, + "z": 13 + }, + { + "flags": 8390659, + "x": 1, + "y": 0, + "z": 13 + }, + { + "flags": 20976643, + "x": -1, + "y": 0, + "z": 14 + }, + { + "flags": 1048835, + "x": 0, + "y": 0, + "z": 14 + }, + { + "flags": 25171971, + "x": 1, + "y": 0, + "z": 14 + } + ], + "depth": 10, + "doorActionName": "", + "doorConfigs": { + "Z:0:0:15": { + "actionName": "", + "disabled": false, + "hasOverride": true, + "keyItemId": "", + "label": "Exit door", + "lockable": false, + "lockedByDefault": false, + "openAngle": 100.0, + "openSpeed": 180.0, + "persistent": false, + "sceneSwitchPath": "demo_scene_exterior.json", + "sceneSwitchTarget": "arrival_b", + "swingReversed": false + }, + "Z:0:0:8": { + "actionName": "", + "disabled": false, + "hasOverride": false, + "keyItemId": "", + "label": "Demo locked door", + "lockable": true, + "lockedByDefault": true, + "openAngle": 100.0, + "openSpeed": 180.0, + "persistent": true, + "sceneSwitchPath": "", + "sceneSwitchTarget": "", + "swingReversed": false + } + }, + "doorMeshName": "", + "doorOpenAngle": 100.0, + "doorOpenSpeed": 180.0, + "doorRectName": "", + "doorSceneSwitchPath": "", + "doorSceneSwitchTarget": "", + "doorSwingReversed": false, + "doorUseMeshMaterial": false, + "doorsEnabled": true, + "extDoorFrameRectName": "", + "extWallRectName": "", + "extWindowFrameRectName": "", + "floorRectName": "floor", + "friction": 0.5, + "furnitureCells": [], + "generationMode": "interiorOnly", + "generationScript": "", + "glassColor": [ + 0.4000000059604645, + 0.6000000238418579, + 0.800000011920929, + 0.3499999940395355 + ], + "glassMaterialName": "", + "glassReflectivity": 0.800000011920929, + "gridUid": "d6f6a1e2-4b5c-4d6e-8f70-a1b2c3d4e5f6", + "height": 1, + "intDoorFrameRectName": "", + "intWallRectName": "", + "intWindowFrameRectName": "", + "roofSideRectName": "", + "roofTopRectName": "", + "width": 10 + }, + "children": [ + { + "children": [], + "clearArea": { + "clearCells": true, + "clearFurniture": true, + "clearRoofs": false, + "clearRooms": false, + "maxX": 8, + "maxY": 1, + "maxZ": 20, + "minX": -8, + "minY": 0, + "minZ": -8 + }, + "id": 4294967786, + "name": { + "name": "r1" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 8589935095, + "name": { + "name": "r2" + }, + "room": { + "connectedRoomIds": [ + "room_1788724060923073709_509" + ], + "createCeiling": true, + "createFloor": true, + "createInteriorWalls": true, + "createWindows": false, + "exits": [ + false, + true, + false, + false + ], + "fillRoomWithFurniture": false, + "furnitureSeed": 42, + "furnitureYOffset": 0.05000000074505806, + "maxX": 2, + "maxY": 1, + "maxZ": 8, + "minX": -1, + "minY": 0, + "minZ": -2, + "persistentId": "room_1788648326350139622_498", + "roomType": "", + "tags": [] + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + }, + { + "children": [], + "id": 4294967816, + "name": { + "name": "r3" + }, + "room": { + "connectedRoomIds": [ + "room_1788648326350139622_498" + ], + "createCeiling": true, + "createFloor": true, + "createInteriorWalls": true, + "createWindows": true, + "exits": [ + false, + true, + false, + false + ], + "fillRoomWithFurniture": false, + "furnitureSeed": 42, + "furnitureYOffset": 0.05000000074505806, + "maxX": 2, + "maxY": 1, + "maxZ": 15, + "minX": -1, + "minY": 0, + "minZ": 8, + "persistentId": "room_1788724060923073709_509", + "roomType": "", + "tags": [] + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + } + ], + "id": 4294967785, + "name": { + "name": "interrior" + }, + "proceduralMaterial": { + "ambient": { + "b": 0.20000000298023224, + "g": 0.20000000298023224, + "r": 0.20000000298023224 + }, + "diffuse": { + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + "diffuseTextureId": "id_1788648541764281950_3", + "materialId": "id_1788648527415023537_1", + "materialName": "ProceduralMat_id_1788648527415023537_1", + "roughness": 0.5, + "shininess": 32.0, + "specular": { + "b": 0.0, + "g": 0.0, + "r": 0.0 + } + }, + "proceduralTexture": { + "colors": [ + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + }, + { + "a": 1.0, + "b": 0.0, + "g": 0.0, + "r": 0.0 + }, + { + "a": 1.0, + "b": 1.0, + "g": 1.0, + "r": 1.0 + } + ], + "namedRects": [ + { + "name": "ceiling", + "u1": 0.10000000149011612, + "u2": 0.20000000298023224, + "v1": 0.0, + "v2": 0.10000000149011612 + }, + { + "name": "floor", + "u1": 0.0, + "u2": 0.10000000149011612, + "v1": 0.0, + "v2": 0.10000000149011612 + } + ], + "textureId": "id_1788648541764281950_3", + "textureName": "ProceduralTex_id_1788648541764281950_3", + "textureSize": 512, + "uvMargin": 0.009999999776482582 + }, + "sceneScript": { + "inlineScript": "-- F6 demo: the internal doorway Z:0:0:8 of this grid is lockable\n-- and locked by default (see the grid's doorConfigs). The first time\n-- the player bumps into the locked door, this handler unlocks it through\n-- the door event contract; the door itself never opens on its own, the\n-- player presses E again after the unlock.\nlocal door_id = \"d6f6a1e2-4b5c-4d6e-8f70-a1b2c3d4e5f6:Z:0:0:8\"\n\necs.subscribe_event(\"door_locked\", function(event, params)\n if params and params.door_id == door_id then\n print(\"[demo] door_locked for \" .. door_id ..\n \" (locked=\" .. tostring(ecs.door.is_locked(door_id)) ..\n \"), unlocking\")\n ecs.send_event(\"door_unlock_\" .. door_id)\n print(\"[demo] door unlocked, locked=\" ..\n tostring(ecs.door.is_locked(door_id)))\n end\nend)\n", + "scriptPath": "" + }, + "transform": { + "position": { + "x": 0.0, + "y": 0.013780713081359863, + "z": 0.0 + }, + "rotation": { + "w": 1.0, + "x": 0.0, + "y": 0.0, + "z": 0.0 + }, + "scale": { + "x": 1.0, + "y": 1.0, + "z": 1.0 + } + } + } + ], + "version": "1.0" +} \ No newline at end of file diff --git a/src/features/editScene/demos/demo-taxi/gen_heightmap.py b/src/features/editScene/demos/demo-taxi/gen_heightmap.py new file mode 100644 index 0000000..4e04234 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/gen_heightmap.py @@ -0,0 +1,142 @@ +#!/usr/bin/env python3 +"""Generate heightmap.bin for the demo-interior-exterior-dynamics terrain. + +NOTE: the exterior scene's terrain (terrainId 4242424300000001) runs in +streaming mode, where base heights come from the terrain's baseNoise +(FastNoiseLite) and this file is NOT sampled — it is only staged next to +the binary (heightmaps/4242424300000001/heightmap.bin) so the loader +finds it. This script documents the historical non-streaming layout and +is kept as the generator of record for that staged file. + +Legacy description (non-streaming mode): + +The exterior scene's terrain entity (terrainId 4242424300000001, +non-streaming, worldSize 500 per page) loads its base heights from +heightmaps/4242424300000001/heightmap.bin via +TerrainSystem::loadSceneHeightmap. File format: uint32 resolution, +then res*res little-endian float32 heights. + +Height profile: a flat disc at y=0 around the origin (the playable area +with the building shell and the scene-switch arrival point), sloping +down to -5 in a ring so the water plane (waterSurfaceY -0.5) is visible +as a lake around the centre. + +Sampling math (see TerrainSystem::sampleBaseLocked / fillPageHeightData +and the visualToPhysicalX/Z helpers): in non-streaming mode the system +loads a fixed 3x3 page grid, so the heightmap covers the physical world +rect [-worldSize, 2*worldSize] on both axes and texel (ix, iz) holds +the height at physical coordinate (-ws + i * 3*ws / res). Physical +space maps to visual (scene) space by a half-page shift on X and a +per-page Z mirror; this script inverts that mapping so every texel gets +the height of the *visual* position it will be rendered at, then +verifies the round trip by re-sampling the generated grid the same +bilinear way the engine does. +""" + +import math +import struct +import sys + +RES = 256 # must match "heightmapSize" in the scene JSON +WORLD_SIZE = 500.0 # per-page world size ("worldSize" in the scene JSON) +FLAT_RADIUS = 60.0 # flat-0 disc radius around the visual origin +EDGE_RADIUS = 160.0 # slope reaches full depth here +DEPTH = -5.0 # lake floor height (below waterSurfaceY -0.5) + + +def profile(r): + """Visual height at distance r from the origin.""" + if r <= FLAT_RADIUS: + return 0.0 + if r >= EDGE_RADIUS: + return DEPTH + t = (r - FLAT_RADIUS) / (EDGE_RADIUS - FLAT_RADIUS) + t = t * t * (3.0 - 2.0 * t) # smoothstep + return DEPTH * t + + +def physical_to_visual(px, pz): + """Invert TerrainSystem::visualToPhysicalX/Z (terrain origin 0,0,0).""" + vx = px - WORLD_SIZE * 0.5 + page = math.floor(pz / WORLD_SIZE) + vz = 2.0 * page * WORLD_SIZE + WORLD_SIZE * 0.5 - pz + return vx, vz + + +def visual_to_physical(vx, vz): + """TerrainSystem::visualToPhysicalX/Z with a zero terrain origin.""" + px = vx + WORLD_SIZE * 0.5 + page = math.floor((vz + WORLD_SIZE * 0.5) / WORLD_SIZE) + pz = 2.0 * page * WORLD_SIZE + WORLD_SIZE * 0.5 - vz + return px, pz + + +def main(): + out_path = sys.argv[1] if len(sys.argv) > 1 else "heightmap.bin" + span = 3.0 * WORLD_SIZE + origin = -WORLD_SIZE + + grid = [] + for iz in range(RES): + row = [] + pz = origin + iz * span / RES + for ix in range(RES): + px = origin + ix * span / RES + vx, vz = physical_to_visual(px, pz) + row.append(profile(math.hypot(vx, vz))) + grid.append(row) + + with open(out_path, "wb") as f: + f.write(struct.pack(" height %8.3f" + % (label, vx, vz, h)) + for vx, vz in [(0.0, 24.0), (0.0, 0.0), (4.0, 30.0), (55.0, 0.0)]: + if abs(sample(vx, vz)) > 1e-4: + print("ERROR: playable area not flat at", vx, vz) + ok = False + for vx, vz in [(200.0, 0.0), (-200.0, 200.0)]: + if sample(vx, vz) > -4.9: + print("ERROR: lake area not deep enough at", vx, vz) + ok = False + if not ok: + sys.exit(1) + print("heightmap written to %s (%dx%d), all checks passed" + % (out_path, RES, RES)) + + +if __name__ == "__main__": + main() diff --git a/src/features/editScene/demos/demo-taxi/heightmap.bin b/src/features/editScene/demos/demo-taxi/heightmap.bin new file mode 100644 index 0000000..97f73bd Binary files /dev/null and b/src/features/editScene/demos/demo-taxi/heightmap.bin differ diff --git a/src/features/editScene/demos/demo-taxi/imgui.ini b/src/features/editScene/demos/demo-taxi/imgui.ini new file mode 100644 index 0000000..c0edfb3 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/imgui.ini @@ -0,0 +1,131 @@ +[Window][Debug##Default] +Pos=60,60 +Size=400,400 +LastUsed=20260908 + +[Window][Entity Hierarchy] +Pos=0,0 +Size=300,1043 +LastUsed=20260908 + +[Window][Property Editor] +Pos=1570,0 +Size=350,1043 +LastUsed=20260908 + +[Window][Load Scene] +Pos=710,321 +Size=500,400 +LastUsed=20260908 + +[Window][Save Scene] +Pos=710,321 +Size=500,400 +LastUsed=20260908 + +[Window][StartupMenu] +Pos=0,0 +Size=1920,1043 + +[Window][Prefab Browser] +Pos=300,300 +Size=250,400 + +[Window][Create Prefab] +Pos=655,364 +Size=305,77 + +[Window][3D Cursor] +Pos=300,100 +Size=280,350 + +[Window][Mesh Browser] +Pos=533,240 +Size=416,406 + +[Window][Action Database (Singleton)] +Pos=326,33 +Size=404,694 + +[Window][Dialogue Settings] +Pos=300,100 +Size=400,500 + +[Window][DialogueBox] +Pos=0,681 +Size=1682,227 + +[Window][Character Class Database] +Pos=303,109 +Size=600,600 + +[Window][Character Registry] +Pos=476,258 +Size=903,429 + +[Window][Delete Prefab] +Pos=797,467 +Size=325,109 + +[Window][PauseMenu] +Pos=0,0 +Size=2490,1536 +LastUsed=20260905 + +[Window][Item Registry] +Pos=60,60 +Size=600,500 + +[Window][Inventory Dialog Config] +Pos=300,100 +Size=350,200 + +[Window][Character Sheet] +Pos=0,0 +Size=1920,1043 + +[Window][Load Game] +Pos=710,321 +Size=500,400 + +[Window][Save Game] +Pos=710,321 +Size=500,400 + +[Window][Animation Tree Registry] +Pos=60,60 +Size=900,600 + +[Window][Confirm Blend Map Resolution Change] +Pos=815,477 +Size=290,105 + +[Window][Confirm Heightmap Resolution Change] +Pos=815,477 +Size=290,105 + +[Window][Road Graph Invalid] +Pos=892,217 +Size=136,127 +LastUsed=20260731 + +[Window][Wedge Geometry Debug] +Pos=10,10 +Size=420,520 +LastUsed=20260814 + +[Window][Road Graph Valid] +Pos=882,486 +Size=156,71 +LastUsed=20260821 + +[Window][Switch Scene] +Pos=710,321 +Size=500,400 +LastUsed=20260906 + +[Window][Open Project] +Pos=300,100 +Size=639,377 +LastUsed=20260908 + diff --git a/src/features/editScene/demos/demo-taxi/inventory_config.json b/src/features/editScene/demos/demo-taxi/inventory_config.json new file mode 100644 index 0000000..dc54a49 --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/inventory_config.json @@ -0,0 +1,4 @@ +{ + "fontPath": "Jupiteroid-Bold.ttf", + "fontSize": 16.0 +} \ No newline at end of file diff --git a/src/features/editScene/demos/demo-taxi/project.h.in b/src/features/editScene/demos/demo-taxi/project.h.in new file mode 100644 index 0000000..3bb789a --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/project.h.in @@ -0,0 +1,7 @@ +#pragma once +/* Generated by CMake from project.json - do not edit. + * Embeds the project parameters into the release binary so it runs its + * project with no --project flag (see GameFeatures202609.md, F8). */ +#define EDITSCENE_PROJECT_APP_NAME "@PROJECT_APP_NAME@" +#define EDITSCENE_PROJECT_START_SCENE "@PROJECT_START_SCENE@" +#define EDITSCENE_PROJECT_GAME_MODE @PROJECT_GAME_MODE_VALUE@ diff --git a/src/features/editScene/demos/demo-taxi/project.json b/src/features/editScene/demos/demo-taxi/project.json new file mode 100644 index 0000000..cccfa5f --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/project.json @@ -0,0 +1,5 @@ +{ + "appName": "demo-taxi", + "startScene": "demo_scene_interior.json", + "gameMode": true +} diff --git a/src/features/editScene/demos/demo-taxi/stage_runtime.cmake b/src/features/editScene/demos/demo-taxi/stage_runtime.cmake new file mode 100644 index 0000000..7052d6a --- /dev/null +++ b/src/features/editScene/demos/demo-taxi/stage_runtime.cmake @@ -0,0 +1,65 @@ +# Stage everything demoTaxi needs into its own directory so it +# runs standalone from +# /src/features/editScene/demos/demo-taxi. +# +# Expected -D arguments: DEMO_DIR, EDITSCENE_BIN, EDITSCENE_SRC, SRC_DIR. +# +# Small demo-owned files are COPIED, except the demo scenes, which are +# SYMLINKED to the source tree so scene edits are visible to the demo +# without a rebuild (the demo never saves scenes, so nothing writes through +# the links); the big pre-staged runtime directories +# are SYMLINKED from the editScene binary directory (Ogre FileSystem +# locations follow symlinks, and copying would duplicate hundreds of MB on +# every build). The symlink targets are populated by the editSceneEditor +# staging, so editSceneEditor must have been built (and run its POST_BUILD +# staging) at least once. + +file(COPY "${EDITSCENE_SRC}/resources.cfg" DESTINATION "${DEMO_DIR}") +file(COPY "${SRC_DIR}/project.json" DESTINATION "${DEMO_DIR}") + +foreach(f demo_scene_interior.json demo_scene_exterior.json) + set(link "${DEMO_DIR}/${f}") + if(EXISTS "${link}" OR IS_SYMLINK "${link}") + file(REMOVE "${link}") + endif() + file(CREATE_LINK "${SRC_DIR}/${f}" "${link}" SYMBOLIC) +endforeach() + +# Terrain heightmap: staged at configure time by a configure_file COPYONLY +# in CMakeLists.txt (to heightmaps/4242424300000001/), which re-copies it +# automatically when the source file changes. Not symlinked: the fixup +# layer and save path write next to it. + +# Character prefab for the spawner's registry entry (registryId 2). It is +# written by a previous editor/game run (CharacterRegistry::savePrefab...), +# not part of the source tree, so copy it from the editScene binary +# directory when present. +file(MAKE_DIRECTORY "${DEMO_DIR}/prefabs") +foreach(f char_2.json) + if(EXISTS "${EDITSCENE_BIN}/prefabs/${f}") + file(COPY "${EDITSCENE_BIN}/prefabs/${f}" + DESTINATION "${DEMO_DIR}/prefabs") + endif() +endforeach() + +foreach(dir resources characters lua-scripts) + set(link "${DEMO_DIR}/${dir}") + if(EXISTS "${link}" OR IS_SYMLINK "${link}") + file(REMOVE_RECURSE "${link}") + endif() + file(CREATE_LINK "${EDITSCENE_BIN}/${dir}" "${link}" SYMBOLIC) +endforeach() + +# Runtime config JSONs loaded at startup relative to the CWD (game mode +# reads startup_menu.json, the registries read the rest — the demo needs +# character_registry.json for the spawner's registryId 2 and +# animation_tree.json for the character's "male1_6" animation tree). They +# only exist after the editor/game has run once; copy them when present so +# the demo behaves the same as when run from the editor binary directory. +foreach(f startup_menu.json character_registry.json character_class.json + items.json item_state.json inventory_config.json + animation_tree.json) + if(EXISTS "${EDITSCENE_BIN}/${f}") + file(COPY "${EDITSCENE_BIN}/${f}" DESTINATION "${DEMO_DIR}") + endif() +endforeach()