diff --git a/Aetheria.State/docs/client-runtime-conformance.md b/Aetheria.State/docs/client-runtime-conformance.md index 98cd4a3fd..f0ec98bc5 100644 --- a/Aetheria.State/docs/client-runtime-conformance.md +++ b/Aetheria.State/docs/client-runtime-conformance.md @@ -6,11 +6,11 @@ gameplay body without replacing it with a new privileged runtime. The daemon owns Aetheria game state, simulation, generated level content, assets, render-field declarations, Eve/CultUI surfaces, and typed operations. Eve owns the game-agnostic surface language: layout, interaction, state -pointers, render-field instructions, and 2D/3D scalar/vector field -visualization contracts. Client runtimes lower those surfaces and submit typed -operations. A runtime may own presentation, input hardware, local caches, native -buffers, and frame timing. It must not own gameplay truth merely because it can -draw the game. +pointers, world-state lowering, render-field instructions, and 2D/3D +scalar/vector field visualization contracts. Client runtimes lower those +surfaces and submit typed operations. A runtime may own presentation, input +hardware, local caches, native buffers, and frame timing. It must not own +gameplay truth merely because it can draw the game. The desired end state is renderless Aetheria. Aetheria should not preserve a Unity, Godot, Electron, or browser side path for game behavior. If a runtime @@ -23,7 +23,7 @@ daemon-authored Eve/CultUI or in a game-agnostic Eve lowering primitive. | --- | --- | --- | | Hermodr | Unspecialized Eve/browser lowering sanity check for the RTS surface. | It reconstructs the Aetheria RTS gameplay surface from daemon-advertised Eve surfaces, typed state pointers, typed operations, render-field declarations, and CultMesh CDN assets without Aetheria-specific renderer code. | | Electron | Player-facing Starbridge RTS client. | It renders the same daemon-authored RTS surface through the shared Eve package, with only app shell, launch, packaging, and runtime ergonomics outside Eve. | -| Unity | Current ARPG reference client and demolition target. | It behaves as a renderer/input shell over daemon state and Eve/CultUI surfaces; remaining GameObject, UI Toolkit, camera, input, and presentation adapters are classified shims or renderer-owned concerns. | +| Unity | Current ARPG reference client and demolition target. | It behaves as a renderer/input shell over daemon state and Eve/CultUI/world-state surfaces; remaining GameObject, UI Toolkit, camera, input, and presentation adapters are classified shims or renderer-owned concerns. | | Godot | Future unspecialized Eve/runtime parity target for the ARPG surface. | It reconstructs the ARPG gameplay surface from daemon API plus Eve/CultUI/render-field specs and CultMesh CDN assets, not from a Unity port or daemon-side Godot mode. | Hermodr is the purity test for the RTS surface. Electron is the shipped RTS @@ -51,6 +51,8 @@ assumptions, or Unity-only gameplay adapters. for 2D or 3D scalar/vector field visualization. - No daemon-published Eve surface that requires a named runtime to understand Aetheria gameplay semantics. +- No Aetheria-owned Unity/Godot/Electron world renderer that should instead be a + game-agnostic Eve lowerer. ## Acceptance Gates @@ -66,6 +68,8 @@ assumptions, or Unity-only gameplay adapters. 7. Eve lowerers can reconstruct the required 2D and 3D gameplay surfaces from daemon-authored state pointers, field documents, asset refs, and operation descriptors without Aetheria runtime branches. +8. World-state lowerers live in Eve or shared runtime packages, while Aetheria + contributes authored surfaces, state documents, assets, and fixtures. Until those gates pass, Aetheria is daemon-authoritative in pieces, not free of Unity as a complete client dependency. diff --git a/README.md b/README.md index 1957c9398..d9e3d32c4 100644 --- a/README.md +++ b/README.md @@ -4,10 +4,10 @@ Aetheria is an ambitious (AA quality) open source tactical action role-playing g Aetheria is being rebuilt as a renderless daemon-owned game. The daemon owns rules, simulation state, level generation, assets, operations, and the high-performance view documents clients need to render the world. Eve/CultUI -owns the portable surface and field-description contract. Unity, Godot, -Electron, Hermodr, and later runtimes should be game-agnostic Eve lowerers: -they render, capture input, cache native views, and submit typed operations -without becoming gameplay authorities. +owns the portable surface, field-description, and world-state lowering +contract. Unity, Godot, Electron, Hermodr, and later runtimes should be +game-agnostic Eve lowerers: they render, capture input, cache native views, and +submit typed operations without becoming gameplay authorities. It is our ambition to forge a new paradigm of open source game development, as to our knowledge there are no other open source projects of this scope building up a foundation from scratch. Game development is notoriously averse to this model and nobody wants to share their shiny toys for fear of losing their competitive advantage. By building and sharing immersive and compelling experiences like this, we hope to change that. @@ -87,8 +87,8 @@ client, shared runtime packages, and the C# Aetheria daemon. The target shape is not "two clients sharing a game library." The target shape is one daemon-owned game publishing typed CultMesh state, render fields, assets, operations, and Eve/CultUI surfaces. Runtime code is a lowering boundary: Unity and Godot lower -ARPG surfaces, Electron and Hermodr lower RTS surfaces, and all of them consume -the same game-agnostic Eve/runtime primitives. +ARPG world surfaces, Electron and Hermodr lower RTS world surfaces, and all of +them consume the same game-agnostic Eve/runtime primitives. ### Third Party Libraries diff --git a/docs/renderless-aetheria-architecture.md b/docs/renderless-aetheria-architecture.md index 23d06f40d..b4b6d9fcd 100644 --- a/docs/renderless-aetheria-architecture.md +++ b/docs/renderless-aetheria-architecture.md @@ -12,10 +12,10 @@ Aetheria should become a renderless daemon-owned game. The Aetheria daemon owns game state, simulation rules, generated content, game-feel settings, authority policy, typed operations, assets, and -high-performance views of live state. Eve owns the portable UI and rendering -instruction contract. Unity, Godot, Electron, Hermodr, and later runtimes lower -Eve surfaces and submit typed operations; they do not own Aetheria gameplay -truth. +high-performance views of live state. Eve owns the portable UI and world-state +rendering instruction contract. Unity, Godot, Electron, Hermodr, and later +runtimes lower Eve surfaces and submit typed operations; they do not own +Aetheria gameplay truth. Hermodr is the RTS sanity check: an unspecialized Eve/browser client must be able to reconstruct the same RTS gameplay surface as Electron from the Eve spec, @@ -86,7 +86,8 @@ state that must be audited before they can be deleted or demoted. ## Invariants - Aetheria gameplay truth lives in daemon-owned typed state, not renderer state. -- Eve surfaces contain the UI and render instructions required by clients. +- Eve surfaces contain the UI and world-state render instructions required by + clients. - Dynamic contents are state pointers or managed document references, not copied live state embedded into the surface document. - CultMesh CDN serves assets advertised by the daemon. @@ -105,6 +106,12 @@ state that must be audited before they can be deleted or demoted. An Aetheria Eve surface should be rich enough to describe both the 2D RTS view and the 3D ARPG view. +This is not only UI Toolkit-style widget lowering. Eve lowerers must be able to +lower world state with different presentation budgets: a compact 2D tactical +map, a richer browser canvas, a Unity or Godot 3D scene, a debug overlay, or a +future room-scale view. The sophistication belongs to the lowering target, but +the semantic instructions belong to Eve and the daemon-authored surface. + The surface should be able to declare: - layout, rows, columns, grids, modal placement, fields, and command bindings; @@ -118,6 +125,9 @@ The surface should be able to declare: - render splat buffers and accumulation rules; - entity/object render rows with asset refs, transforms, labels, and selection metadata; +- presentation-quality hints, level-of-detail policies, and native-view + descriptors that let clients choose an appropriate 2D or 3D lowering without + changing gameplay meaning; - asset refs resolved through CultMesh CDN. The Eve package should own the game-agnostic lowering primitives for these @@ -125,6 +135,36 @@ contracts. Aetheria may define game documents and author surfaces, but it should not require Electron, Hermodr, Unity, or Godot to carry private Aetheria rendering knowledge. +## World-State Lowering + +World-state lowering is an Eve responsibility, not an Aetheria client +responsibility. + +The Aetheria daemon can publish a view of world state at several levels: + +- canonical typed game documents for rules and committed facts; +- high-performance SoA/native view descriptors for hot rendering paths; +- field documents for scalar/vector/color data; +- object/entity render rows for things with transforms, sprites, meshes, labels, + selection metadata, and operation affordances; +- asset refs for icons, sprites, materials, meshes, shaders, and generated + textures. + +Eve lowerers decide how sophisticated the presentation should be in a particular +runtime. Hermodr might draw an RTS surface as a 2D canvas with isolines, icons, +labels, and modal UI. Electron might use the same lowering path with richer +shell integration. Unity or Godot might lower the ARPG surface into meshes, +materials, particles, UI panels, input affordances, and camera-relative +overlays. Those are quality tiers over the same semantic surface, not separate +Aetheria clients with private gameplay knowledge. + +If a lowerer needs to know that a value is "Aetheria gravity" in order to render +it, the contract is wrong. The surface should say it is a scalar field with +domain, units, sampling rules, visualization options, and asset/material refs. +If a lowerer needs to know that a row is an "Aetheria planet" to draw it, the +contract is wrong. The row should carry an entity kind, transform, display +label, state refs, and daemon-advertised assets. + ## Field Documents Gravity is a 2D scalar field for the RTS view. It should be produced from @@ -164,18 +204,19 @@ own Aetheria gameplay semantics. Unity: Current ARPG reference client and migration source. It may own engine -presentation, input capture, camera, GameObject restoration, and temporary -adapters. It should not remain the owner of rules, state, level generation, -physics truth, or UI semantics. +presentation, input capture, camera, GameObject restoration, native world-state +lowering, and temporary adapters. It should not remain the owner of rules, +state, level generation, physics truth, or UI/world semantics. Godot: Future ARPG conformance runtime. It should prove the ARPG client can be rebuilt from the daemon and Eve contract rather than ported from Unity scene authority. Eve: -Game-agnostic surface and lowering contract. Eve owns reusable primitives for -state binding, operation invocation, modal placement, field visualization, -asset refs, and runtime-neutral UI/render semantics. +Game-agnostic surface and world-state lowering contract. Eve owns reusable +primitives for state binding, operation invocation, modal placement, 2D/3D +field visualization, asset refs, native-view descriptors, and runtime-neutral +UI/render semantics. Aetheria: Game daemon, documents, rules, authored surfaces, assets, generation, @@ -211,6 +252,8 @@ When enforcement starts, the verifier should prove: - asset refs come from daemon manifests and CultMesh CDN; - field visualization settings come from Eve/daemon documents, not renderer constants. +- world-state lowerers live in Eve packages or generic runtime packages, not as + Aetheria-specific client renderer code. The goal is not to outlaw useful runtime code. The goal is to make ownership legible: renderers render, the daemon decides, Eve carries the contract.