feat: dominium standalone — simulador de campo medio sobre Llimphi
Front-door publicable de dominium: los 9 crates propios como path members; Llimphi, app-bus, rimay-localize, wawa-config y pluma-notebook por git-dep al monorepo tawasuyu.git (branch=main). cargo check --workspace --all-targets pasa exit 0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,42 @@
|
||||
[package]
|
||||
name = "dominium-app-llimphi"
|
||||
version.workspace = true
|
||||
edition.workspace = true
|
||||
rust-version.workspace = true
|
||||
license.workspace = true
|
||||
authors.workspace = true
|
||||
publish.workspace = true
|
||||
description = "dominium-app-llimphi — la ventana viva del simulador de campo medio sobre Llimphi. Reemplazo del `dominium-app` GPUI: arma la cadena `core → physics → iso → render-plan → canvas-llimphi`, corre un loop de tick (~11 Hz) en un thread aparte que reentra al update vía `Handle::dispatch`, y compone canvas + panel de stats + controles play/pause/reseed."
|
||||
|
||||
[[bin]]
|
||||
name = "dominium-app-llimphi"
|
||||
path = "src/main.rs"
|
||||
|
||||
[dependencies]
|
||||
dominium-canvas-llimphi = { path = "../dominium-canvas-llimphi" }
|
||||
dominium-core = { path = "../dominium-core" }
|
||||
dominium-iso = { path = "../dominium-iso" }
|
||||
dominium-render-plan = { path = "../dominium-render-plan" }
|
||||
dominium-sim = { path = "../dominium-sim" }
|
||||
llimphi-ui = { workspace = true }
|
||||
llimphi-theme = { workspace = true }
|
||||
llimphi-widget-button = { workspace = true }
|
||||
llimphi-widget-slider = { workspace = true }
|
||||
llimphi-widget-text-input = { workspace = true }
|
||||
llimphi-widget-menubar = { workspace = true }
|
||||
llimphi-widget-edit-menu = { workspace = true }
|
||||
llimphi-widget-context-menu = { workspace = true }
|
||||
llimphi-motion = { workspace = true }
|
||||
llimphi-clipboard = { workspace = true }
|
||||
app-bus = { workspace = true }
|
||||
serde = { workspace = true, features = ["derive"] }
|
||||
serde_json = { workspace = true }
|
||||
directories = { workspace = true }
|
||||
rimay-localize = { workspace = true }
|
||||
wawa-config = { workspace = true }
|
||||
wawa-config-llimphi = { workspace = true }
|
||||
|
||||
[dev-dependencies]
|
||||
# Sólo para el example `pantallazo_dominium` (volcado headless a PNG).
|
||||
pollster = { workspace = true }
|
||||
png = { workspace = true }
|
||||
@@ -0,0 +1,17 @@
|
||||
# dominium-app-llimphi
|
||||
|
||||
> App de [dominium](../README.md): canvas + panel de control + loop 11 Hz.
|
||||
|
||||
Binario que monta el canvas ([`dominium-canvas-llimphi`](../dominium-canvas-llimphi/README.md)) + panel con sliders (seed, dt, brightness por capa, conceptos activos), play/pause/step, snapshot dump. Loop a 11 Hz por default (configurable). Carga/guarda config via `wawa-config-llimphi`.
|
||||
|
||||
## Uso
|
||||
|
||||
```sh
|
||||
cargo run --release -p dominium-app-llimphi
|
||||
```
|
||||
|
||||
## Deps
|
||||
|
||||
- [`dominium-core`](../dominium-core/README.md), [`dominium-physics`](../dominium-physics/README.md), [`dominium-canvas-llimphi`](../dominium-canvas-llimphi/README.md)
|
||||
- [`llimphi-ui`](../../../02_ruway/llimphi/)
|
||||
- [`wawa-config-llimphi`](../../../shared/wawa-config-llimphi/)
|
||||
@@ -0,0 +1,17 @@
|
||||
# dominium-app-llimphi
|
||||
|
||||
> [dominium](../README.md) app: canvas + control panel + 11 Hz loop.
|
||||
|
||||
Binary that mounts the canvas ([`dominium-canvas-llimphi`](../dominium-canvas-llimphi/README.md)) + panel with sliders (seed, dt, brightness per layer, active concepts), play/pause/step, snapshot dump. Default loop at 11 Hz (configurable). Loads/saves config via `wawa-config-llimphi`.
|
||||
|
||||
## Usage
|
||||
|
||||
```sh
|
||||
cargo run --release -p dominium-app-llimphi
|
||||
```
|
||||
|
||||
## Deps
|
||||
|
||||
- [`dominium-core`](../dominium-core/README.md), [`dominium-physics`](../dominium-physics/README.md), [`dominium-canvas-llimphi`](../dominium-canvas-llimphi/README.md)
|
||||
- [`llimphi-ui`](../../../02_ruway/llimphi/)
|
||||
- [`wawa-config-llimphi`](../../../shared/wawa-config-llimphi/)
|
||||
@@ -0,0 +1,76 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": "iglesia",
|
||||
"sprite_id": 1,
|
||||
"pos_x": 16.0,
|
||||
"pos_y": 16.0,
|
||||
"radius": 10.0,
|
||||
"mods": { "materia": -0.05, "psique": 0.40, "poder": 0.10, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 18.0 }, "forced_action": 2, "duration": 40 }
|
||||
},
|
||||
{
|
||||
"id": "banco-central",
|
||||
"sprite_id": 2,
|
||||
"pos_x": 64.0,
|
||||
"pos_y": 18.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": 0.00, "psique": -0.05, "poder": 0.25, "oro": -0.15 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 25 }
|
||||
},
|
||||
{
|
||||
"id": "comuna",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 18.0,
|
||||
"pos_y": 60.0,
|
||||
"radius": 12.0,
|
||||
"mods": { "materia": 0.18, "psique": 0.05, "poder": -0.10, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 10.0 }, "forced_action": 3, "duration": 30 }
|
||||
},
|
||||
{
|
||||
"id": "laboratorio-rebelde",
|
||||
"sprite_id": 4,
|
||||
"pos_x": 64.0,
|
||||
"pos_y": 62.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": -0.02, "psique": 0.25, "poder": -0.05, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EdadSobre": 80 }, "forced_action": 4, "duration": 15 }
|
||||
},
|
||||
{
|
||||
"id": "imperio",
|
||||
"sprite_id": 5,
|
||||
"pos_x": 40.0,
|
||||
"pos_y": 8.0,
|
||||
"radius": 14.0,
|
||||
"mods": { "materia": -0.08, "psique": -0.05, "poder": 0.45, "oro": 0.10 },
|
||||
"hack": { "trigger": { "EdadSobre": 60 }, "forced_action": 5, "duration": 35 }
|
||||
},
|
||||
{
|
||||
"id": "casino",
|
||||
"sprite_id": 6,
|
||||
"pos_x": 10.0,
|
||||
"pos_y": 40.0,
|
||||
"radius": 8.0,
|
||||
"mods": { "materia": -0.04, "psique": 0.10, "poder": -0.02, "oro": 0.20 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 12 }
|
||||
},
|
||||
{
|
||||
"id": "mercado",
|
||||
"sprite_id": 7,
|
||||
"pos_x": 40.0,
|
||||
"pos_y": 40.0,
|
||||
"radius": 11.0,
|
||||
"mods": { "materia": 0.05, "psique": 0.02, "poder": 0.00, "oro": 0.06 },
|
||||
"hack": { "trigger": "Always", "forced_action": 3, "duration": 18 }
|
||||
},
|
||||
{
|
||||
"id": "templo-andino",
|
||||
"sprite_id": 8,
|
||||
"pos_x": 70.0,
|
||||
"pos_y": 72.0,
|
||||
"radius": 10.0,
|
||||
"mods": { "materia": 0.06, "psique": 0.22, "poder": -0.02, "oro": 0.02 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 25.0 }, "forced_action": 2, "duration": 50 }
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,703 @@
|
||||
//! **Showreel** de `dominium` — el simulador determinista de campo medio.
|
||||
//!
|
||||
//! No es eye-candy abstracto: monta la **visualización real** de dominium —
|
||||
//! la maqueta isométrica que produce `dominium-render-plan` y pinta
|
||||
//! `dominium-canvas-llimphi::canvas_view` — alimentada por una simulación
|
||||
//! **viva** de `dominium-physics` que avanza tick a tick a lo largo del
|
||||
//! reel. Lo que ves en cada frame es una sociedad de lemmings fluyendo
|
||||
//! sobre el sustrato numérico (5 capas), con los Conceptos (iglesia /
|
||||
//! banco / comuna / laboratorio) emitiendo sus campos. El motor sólo suma
|
||||
//! flotantes; la civilización emerge.
|
||||
//!
|
||||
//! Render **headless y determinista**: una simulación se siembra con seed
|
||||
//! fijo y se avanza `N_TICKS_PRE` ticks; luego, frame `i` de `N` →
|
||||
//! `t = i/(N-1)` → se elige el snapshot vivo correspondiente → se arma el
|
||||
//! `RenderPlan` con la cámara/relieve del frame → vello → wgpu → PNG.
|
||||
//!
|
||||
//! Beats (rediseñados 2026-06-16 para que el reel TENGA MOVIMIENTO):
|
||||
//! - **cold-open** (0–8%): trazo bezier draw-on + punto teal, sobre negro.
|
||||
//! Breve — no debe dominar.
|
||||
//! - **diorama** (6–100%): la maqueta iso real corre TODO el resto del reel
|
||||
//! con la cámara en movimiento CONTINUO: un **zoom-in** claro (la escala
|
||||
//! iso casi se duplica) combinado con un **paneo** que recorre el
|
||||
//! continente en arco (el nodo del canvas es más grande que el viewport y
|
||||
//! se desliza). La simulación avanza varios ticks por frame para que
|
||||
//! lemmings/réplicas/migración se muevan a ojo. La cámara es la fuente
|
||||
//! principal de dinamismo: cada frame se ve distinto.
|
||||
//! - **wordmark** (86–100%): "dominium" + subtítulo, diorama en leve
|
||||
//! fade-out detrás. (El viejo beat ψ de clústeres k-means se eliminó:
|
||||
//! dejaba ~96% de lemmings en un clúster y el recoloreo era invisible —
|
||||
//! un beat muerto. Mejor sacarlo que fingirlo.)
|
||||
//!
|
||||
//! ```text
|
||||
//! cargo run -p dominium-app-llimphi --example dominium_showreel --release -- \
|
||||
//! [out_dir] [n_frames] [W] [H]
|
||||
//! ```
|
||||
//! Defaults: `out_dir=showreel_frames_dominium`, `n_frames=300`, `W=1600`, `H=900`.
|
||||
#![allow(dead_code)]
|
||||
|
||||
// La app es un binario sin lib: incluimos sus módulos reales por `#[path]`
|
||||
// para usar exactamente el mismo `Sim`, colores y pack que la app.
|
||||
#[path = "../src/consts.rs"]
|
||||
mod consts;
|
||||
#[path = "../src/model.rs"]
|
||||
mod model;
|
||||
#[path = "../src/packs.rs"]
|
||||
mod packs;
|
||||
#[path = "../src/sim.rs"]
|
||||
mod sim;
|
||||
#[path = "../src/view.rs"]
|
||||
mod view;
|
||||
#[path = "../src/worldgen.rs"]
|
||||
mod worldgen;
|
||||
|
||||
use std::fs::{create_dir_all, File};
|
||||
use std::io::BufWriter;
|
||||
|
||||
use dominium_core::{SimParams, World};
|
||||
use dominium_iso::{IsoProjector, ZWeights};
|
||||
use dominium_render_plan::{build_plan, PlanConfig, RenderMode, RenderPlan, SpritePrim};
|
||||
use dominium_sim::Sim;
|
||||
|
||||
use llimphi_ui::llimphi_hal::{wgpu, Hal};
|
||||
use llimphi_ui::llimphi_layout::taffy;
|
||||
use llimphi_ui::llimphi_layout::taffy::prelude::{
|
||||
length, percent, Position, Size, Style,
|
||||
};
|
||||
use llimphi_ui::llimphi_layout::taffy::Rect;
|
||||
use llimphi_ui::llimphi_layout::LayoutTree;
|
||||
use llimphi_ui::llimphi_raster::peniko::{self, Color, Gradient};
|
||||
use llimphi_ui::llimphi_raster::{vello, Renderer};
|
||||
use llimphi_ui::llimphi_text::{draw_layout_brush_xf, measurement, Alignment, Typesetter};
|
||||
use llimphi_theme::motion;
|
||||
use llimphi_ui::{measure_text_node, mount, paint, PaintRect, View};
|
||||
use llimphi_ui::llimphi_raster::kurbo::{Affine, BezPath, Circle, Point, Stroke};
|
||||
|
||||
use dominium_canvas_llimphi::canvas_view;
|
||||
|
||||
use crate::consts::{KMEANS_REFRESH_TICKS, LEMMINGS, SNAPSHOT_RING_CAP, TRAIL_CAP};
|
||||
use crate::packs::default_conceptos;
|
||||
use crate::worldgen::bioma_palette;
|
||||
|
||||
const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
|
||||
|
||||
/// Ticks que avanzamos ANTES de empezar a capturar — deja que la sociedad
|
||||
/// arranque (réplicas, primeros asentamientos) antes del primer frame.
|
||||
const N_TICKS_PRE: u64 = 8;
|
||||
|
||||
/// Ticks de simulación que avanzamos POR cada frame capturado. Con 1 tick
|
||||
/// el cambio entre frames es imperceptible (el campo medio se mueve lento);
|
||||
/// con varios, lemmings/réplicas/migración se mueven a ojo desnudo.
|
||||
const TICKS_PER_FRAME: u64 = 4;
|
||||
|
||||
/// Grilla del reel — MÁS CHICA que la de la app (240). Cada celda emite un
|
||||
/// techo + caras laterales: a 240×240 son ~150k polígonos y, a 1600×900, el
|
||||
/// rasterizador por software del entorno wedgea y produce frames negros. Con
|
||||
/// una grilla menor la maqueta es idéntica en carácter pero la escena pesa
|
||||
/// una fracción, y el render sale vivo de punta a punta. (La app real sigue
|
||||
/// usando 240; esto es sólo presentación del reel.)
|
||||
const SHOW_GRID: usize = 120;
|
||||
|
||||
/// Color de acento (teal de marca tawasuyu).
|
||||
const ACCENT: Color = Color::from_rgba8(0x2B, 0xD9, 0xA6, 0xFF);
|
||||
|
||||
// ───────────────────────── utilidades ─────────────────────────
|
||||
|
||||
fn with_alpha(c: Color, a: f32) -> Color {
|
||||
let [r, g, b, _] = c.components;
|
||||
Color::new([r, g, b, a.clamp(0.0, 1.0)])
|
||||
}
|
||||
|
||||
fn lerp(a: f64, b: f64, t: f64) -> f64 {
|
||||
a + (b - a) * t
|
||||
}
|
||||
|
||||
/// Reescala `t` desde el subintervalo `[lo,hi]` a `[0,1]`, clampado.
|
||||
fn seg(t: f32, lo: f32, hi: f32) -> f32 {
|
||||
((t - lo) / (hi - lo)).clamp(0.0, 1.0)
|
||||
}
|
||||
|
||||
// ───────────────────────── snapshots de simulación ─────────────────────────
|
||||
|
||||
/// Un fotograma vivo de la simulación: el `World` + las asignaciones de
|
||||
/// clúster ψ vigentes (para el modo `PsiCluster`).
|
||||
struct SimSnapshot {
|
||||
world: World,
|
||||
clusters: Vec<u8>,
|
||||
}
|
||||
|
||||
/// Calibración idéntica a `Dominium::init` / `pantallazo_dominium`: la
|
||||
/// población crece de forma controlada (réplica barata, regrowth limitado).
|
||||
fn demo_params() -> SimParams {
|
||||
SimParams {
|
||||
diffusion_rate: 0.02,
|
||||
entropy_rate: 0.004,
|
||||
regrowth_rate: 0.004,
|
||||
carrying_capacity: 40.0,
|
||||
metabolic_cost: 0.05,
|
||||
replicate_threshold: 28.0,
|
||||
child_energy_frac: 0.45,
|
||||
abundance_threshold: 50.0,
|
||||
..SimParams::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Relieve visual por bioma (mares hunden, picos elevan) — calco de `init`.
|
||||
fn demo_weights() -> ZWeights {
|
||||
ZWeights {
|
||||
materia: 0.02,
|
||||
psique: -0.075,
|
||||
poder: 0.40,
|
||||
oro: 0.0,
|
||||
degradacion: 1.30,
|
||||
}
|
||||
}
|
||||
|
||||
/// Corre la simulación real y captura `n` snapshots vivos (uno por frame),
|
||||
/// avanzando un tick de `dominium-physics` por cada uno. Determinista: mismo
|
||||
/// seed → misma película, bit a bit.
|
||||
fn capture_snapshots(n: usize) -> Vec<SimSnapshot> {
|
||||
let rng_seed = 0xD0_31_31_07_u64;
|
||||
let seeder =
|
||||
|s: u64| dominium_core::worldgen::seed(s, SHOW_GRID, LEMMINGS, default_conceptos());
|
||||
let mut sim = Sim::new(
|
||||
seeder(rng_seed),
|
||||
demo_params(),
|
||||
rng_seed,
|
||||
SNAPSHOT_RING_CAP,
|
||||
TRAIL_CAP,
|
||||
KMEANS_REFRESH_TICKS,
|
||||
true,
|
||||
Box::new(seeder),
|
||||
);
|
||||
|
||||
// Calentamiento: que la sociedad ya esté en marcha al primer frame.
|
||||
for _ in 0..N_TICKS_PRE {
|
||||
sim.advance(true);
|
||||
}
|
||||
|
||||
let mut out = Vec::with_capacity(n);
|
||||
for _ in 0..n {
|
||||
// Varios ticks por frame: el movimiento de la sociedad (lemmings,
|
||||
// réplicas, migración) se nota frame a frame, no sólo la cámara.
|
||||
for _ in 0..TICKS_PER_FRAME {
|
||||
sim.advance(false);
|
||||
}
|
||||
out.push(SimSnapshot {
|
||||
world: sim.world.clone(),
|
||||
clusters: sim.cluster_assignments.clone(),
|
||||
});
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ───────────────────────── la escena por frame ─────────────────────────
|
||||
|
||||
/// Desplaza TODA la geometría del plan por `(dx, dy)` pero deja la caja
|
||||
/// envolvente (`min/max`) intacta. `canvas_view` centra el plan según su
|
||||
/// bbox, así que al mover la geometría sin mover el bbox la maqueta se
|
||||
/// **panea** dentro del rect — la cámara recorre el continente. (Hacerlo
|
||||
/// así, en vez de agrandar el nodo del canvas, evita un nodo gigante que en
|
||||
/// el render headless por software dejaba el readback en frame congelado.)
|
||||
fn pan_plan(mut plan: RenderPlan, dx: f32, dy: f32) -> RenderPlan {
|
||||
for q in &mut plan.quads {
|
||||
q.x += dx;
|
||||
q.y += dy;
|
||||
}
|
||||
for p in &mut plan.polygons {
|
||||
for v in &mut p.vertices {
|
||||
v.0 += dx;
|
||||
v.1 += dy;
|
||||
}
|
||||
}
|
||||
for g in &mut plan.glyphs {
|
||||
g.x += dx;
|
||||
g.y += dy;
|
||||
}
|
||||
for s in &mut plan.sprites {
|
||||
match s {
|
||||
SpritePrim::Fill { points, .. } | SpritePrim::Stroke { points, .. } => {
|
||||
for pt in points {
|
||||
pt.0 += dx;
|
||||
pt.1 += dy;
|
||||
}
|
||||
}
|
||||
SpritePrim::Disc { cx, cy, .. } => {
|
||||
*cx += dx;
|
||||
*cy += dy;
|
||||
}
|
||||
}
|
||||
}
|
||||
// bbox a propósito SIN tocar: el paneo nace de la diferencia entre el
|
||||
// centro del bbox (donde canvas_view ancla) y la geometría ya movida.
|
||||
plan
|
||||
}
|
||||
|
||||
/// Recorta del plan toda la geometría que cae FUERA del viewport (con un
|
||||
/// margen). Imprescindible a zoom alto: la maqueta de 240×240 emite ~150k
|
||||
/// polígonos, pero acercada sólo una fracción es visible — pintar los 150k a
|
||||
/// 1600×900 satura el rasterizador por software y wedgea el device. Culling
|
||||
/// deja sólo lo on-screen y mantiene la escena liviana de punta a punta.
|
||||
///
|
||||
/// `canvas_view` ancla el centro del bbox en el centro del rect, así que la
|
||||
/// posición en pantalla de un vértice es `vértice + (centro_rect − centro_bbox)`.
|
||||
/// El bbox se deja INTACTO (el culling no debe mover la cámara).
|
||||
fn cull_plan(mut plan: RenderPlan, cw: f64, ch: f64, margin: f32) -> RenderPlan {
|
||||
let bbox_cx = (plan.min_x + plan.max_x) * 0.5;
|
||||
let bbox_cy = (plan.min_y + plan.max_y) * 0.5;
|
||||
let off_x = cw as f32 * 0.5 - bbox_cx;
|
||||
let off_y = ch as f32 * 0.5 - bbox_cy;
|
||||
let lo_x = -margin;
|
||||
let lo_y = -margin;
|
||||
let hi_x = cw as f32 + margin;
|
||||
let hi_y = ch as f32 + margin;
|
||||
let on_screen = |x: f32, y: f32, w: f32, h: f32| -> bool {
|
||||
let sx = x + off_x;
|
||||
let sy = y + off_y;
|
||||
sx + w >= lo_x && sx <= hi_x && sy + h >= lo_y && sy <= hi_y
|
||||
};
|
||||
plan.quads.retain(|q| on_screen(q.x, q.y, q.w, q.h));
|
||||
plan.polygons.retain(|p| {
|
||||
let (mut nx, mut ny, mut xx, mut xy) = (f32::MAX, f32::MAX, f32::MIN, f32::MIN);
|
||||
for (vx, vy) in p.vertices {
|
||||
nx = nx.min(vx);
|
||||
ny = ny.min(vy);
|
||||
xx = xx.max(vx);
|
||||
xy = xy.max(vy);
|
||||
}
|
||||
on_screen(nx, ny, xx - nx, xy - ny)
|
||||
});
|
||||
plan
|
||||
}
|
||||
|
||||
/// Arma el `RenderPlan` de un snapshot con la escala iso del frame `t`. El
|
||||
/// zoom-in del reel se logra ramplando `iso.scale` (la cámara se acerca).
|
||||
fn plan_for(snap: &SimSnapshot, weights: &ZWeights, scale: f32) -> RenderPlan {
|
||||
let iso = IsoProjector::new(scale, 0.55);
|
||||
let cfg = PlanConfig {
|
||||
tile: scale,
|
||||
lemming_size: 2.6,
|
||||
lemming_lift: 0.6,
|
||||
concepto_size: 7.5,
|
||||
concepto_lift: 2.0,
|
||||
light_dir: (0.55, 0.35),
|
||||
andina_layers: 0,
|
||||
andina_threshold: 1.0,
|
||||
palette: bioma_palette(),
|
||||
render_mode: RenderMode::Composite,
|
||||
texture: false,
|
||||
};
|
||||
build_plan(&snap.world, &iso, weights, &cfg)
|
||||
}
|
||||
|
||||
/// Overlays vector (cold-open + wordmark + punto firma) sobre un nodo
|
||||
/// full-screen, en función de `t`.
|
||||
fn draw_overlays(scene: &mut vello::Scene, ts: &mut Typesetter, t: f32, cw: f64, ch: f64) {
|
||||
// ── COLD OPEN (0–8%) ───────────────────────────────────────────
|
||||
let b1 = seg(t, 0.0, 0.05);
|
||||
let line_vis = 1.0 - seg(t, 0.05, 0.08);
|
||||
if line_vis > 0.001 {
|
||||
let cx = cw / 2.0;
|
||||
let cy = ch / 2.0;
|
||||
let mut path = BezPath::new();
|
||||
path.move_to((cx - 360.0, cy + 40.0));
|
||||
let c1 = (cx - 150.0, cy - 220.0);
|
||||
let c2 = (cx + 150.0, cy + 220.0);
|
||||
let p3 = (cx + 360.0, cy - 40.0);
|
||||
let cb = vello::kurbo::CubicBez::new(
|
||||
Point::new(cx - 360.0, cy + 40.0),
|
||||
Point::new(c1.0, c1.1),
|
||||
Point::new(c2.0, c2.1),
|
||||
Point::new(p3.0, p3.1),
|
||||
);
|
||||
use vello::kurbo::ParamCurve;
|
||||
let draw_on = motion::ease_out_cubic(seg(t, 0.01, 0.055)) as f64;
|
||||
let mut trimmed = BezPath::new();
|
||||
let mut head = cb.p0;
|
||||
trimmed.move_to(cb.p0);
|
||||
let steps = 96;
|
||||
for k in 1..=steps {
|
||||
let u = (k as f64 / steps as f64) * draw_on;
|
||||
let pt = cb.eval(u);
|
||||
trimmed.line_to(pt);
|
||||
head = pt;
|
||||
}
|
||||
let line_col = with_alpha(ACCENT, 0.9 * line_vis);
|
||||
scene.stroke(&Stroke::new(2.0), Affine::IDENTITY, line_col, None, &trimmed);
|
||||
let pop = motion::ease_out_back(b1) as f64;
|
||||
let r = (4.0_f64 + 7.0 * pop).max(0.0);
|
||||
let dot_a = (b1 * line_vis).clamp(0.0, 1.0);
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
with_alpha(ACCENT, 0.18 * dot_a),
|
||||
None,
|
||||
&Circle::new(head, r * 3.2),
|
||||
);
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
with_alpha(ACCENT, dot_a),
|
||||
None,
|
||||
&Circle::new(head, r),
|
||||
);
|
||||
}
|
||||
|
||||
// ── WORDMARK (86–100%) ─────────────────────────────────────────
|
||||
let word_in = seg(t, 0.86, 0.95);
|
||||
let word_a = motion::ease_out_cubic(word_in);
|
||||
if word_a > 0.001 {
|
||||
let size = 136.0_f32;
|
||||
let layout = ts.layout(
|
||||
"dominium", size, None, Alignment::Start, 1.0, false, None, 800.0, false, false,
|
||||
);
|
||||
let m = measurement(&layout);
|
||||
let rise = lerp(26.0, 0.0, word_a as f64);
|
||||
let ox = (cw - m.width as f64) / 2.0;
|
||||
let oy = (ch - m.height as f64) / 2.0 - 22.0 + rise;
|
||||
let brush = peniko::Brush::Solid(with_alpha(Color::from_rgba8(0xF2, 0xF4, 0xF3, 0xFF), word_a));
|
||||
draw_layout_brush_xf(scene, &layout, &brush, Affine::translate((ox, oy)));
|
||||
|
||||
let sub_a = motion::ease_out_cubic(seg(t, 0.90, 0.99));
|
||||
if sub_a > 0.001 {
|
||||
let ssz = 25.0_f32;
|
||||
let sub = ts.layout(
|
||||
"un simulador donde la civilización emerge de la aritmética",
|
||||
ssz, None, Alignment::Start, 1.0, false, None, 400.0, false, false,
|
||||
);
|
||||
let sm = measurement(&sub);
|
||||
let dot_r = 6.0;
|
||||
let block_w = sm.width as f64 + dot_r * 2.0 + 14.0;
|
||||
let sx = (cw - block_w) / 2.0;
|
||||
let sy = oy + m.height as f64 + 20.0;
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
with_alpha(ACCENT, sub_a),
|
||||
None,
|
||||
&Circle::new(Point::new(sx + dot_r, sy + ssz as f64 * 0.42), dot_r),
|
||||
);
|
||||
let sbrush = peniko::Brush::Solid(with_alpha(Color::from_rgba8(0x9A, 0xA3, 0xA0, 0xFF), sub_a));
|
||||
draw_layout_brush_xf(scene, &sub, &sbrush, Affine::translate((sx + dot_r * 2.0 + 14.0, sy)));
|
||||
}
|
||||
}
|
||||
|
||||
// ── punto teal de firma (esquina inf-der) ───────────────────────
|
||||
let corner_a = seg(t, 0.04, 0.09) * (1.0 - seg(t, 0.84, 0.90));
|
||||
if corner_a > 0.001 {
|
||||
let cx = cw - 54.0;
|
||||
let cy = ch - 54.0;
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
with_alpha(ACCENT, 0.16 * corner_a),
|
||||
None,
|
||||
&Circle::new(Point::new(cx, cy), 18.0),
|
||||
);
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
with_alpha(ACCENT, 0.9 * corner_a),
|
||||
None,
|
||||
&Circle::new(Point::new(cx, cy), 6.0),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Construye el árbol `View` del frame `t`.
|
||||
fn build_view(
|
||||
t: f32,
|
||||
cw: f64,
|
||||
ch: f64,
|
||||
snaps: &[SimSnapshot],
|
||||
weights: &ZWeights,
|
||||
bg: Color,
|
||||
) -> View<()> {
|
||||
// Snapshot vivo: el diorama se ve a partir de ~6%; antes es el cold-open
|
||||
// sobre negro. Mapeamos el tramo [0.06, 1.0] de t al índice de snapshot
|
||||
// para que la simulación corra durante todo el reel.
|
||||
let diorama_t = seg(t, 0.06, 1.0);
|
||||
let idx = ((diorama_t * (snaps.len() as f32 - 1.0)).round() as usize).min(snaps.len() - 1);
|
||||
let snap = &snaps[idx];
|
||||
|
||||
// Entrada del diorama: fade-in rápido (6–14%) y leve fade-out bajo el
|
||||
// wordmark (no a negro — la maqueta sigue viva detrás del título).
|
||||
let in_a = motion::ease_out_cubic(seg(t, 0.06, 0.14));
|
||||
let out_a = 1.0 - 0.55 * motion::ease_in_out_cubic(seg(t, 0.86, 0.97)) as f32;
|
||||
let diorama_a = (in_a * out_a).clamp(0.0, 1.0) as f64;
|
||||
|
||||
// ── CÁMARA: zoom-in continuo + paneo a lo largo de TODO el reel.
|
||||
// CLAVE: la velocidad de cámara debe ser ~constante (lineal), NO un
|
||||
// ease-in-out — un ease-in-out concentra todo el movimiento en los bordes
|
||||
// y deja un PLATEAU muerto en el medio (frames idénticos). Acá `cam`
|
||||
// avanza lineal con `t`, así CADA frame difiere del anterior por igual.
|
||||
let cam = seg(t, 0.06, 1.0) as f64;
|
||||
// Zoom: acercamiento parejo y perceptible (lineal). La grilla del reel es
|
||||
// 120 (la mitad lineal de la app), así que la escala arranca alta para
|
||||
// que el continente llene el cuadro y casi se duplica hacia el primer
|
||||
// plano. Con culling la escena se mantiene liviana en todo el rango.
|
||||
let scale = lerp(6.0, 11.0, cam) as f32;
|
||||
|
||||
// Paneo: desplazamos la geometría del plan (sin tocar su bbox), así
|
||||
// `canvas_view` —que ancla en el centro del bbox— deja la maqueta corrida
|
||||
// dentro del rect. Recorrido en arco diagonal (avance lineal en X +
|
||||
// curva en Y) para que la cámara cruce el continente revelando regiones
|
||||
// distintas a medida que el zoom aprieta. El nodo sigue siendo del tamaño
|
||||
// del viewport (estable en el render headless).
|
||||
const PAN_AMP_X: f64 = 620.0;
|
||||
const PAN_AMP_Y: f64 = 360.0;
|
||||
// X: barrido lineal izquierda→derecha (velocidad constante).
|
||||
let pan_x = lerp(PAN_AMP_X, -PAN_AMP_X, cam);
|
||||
// Y: avance lineal arriba→abajo MÁS un arco (sin) — sobrevuelo, no recta;
|
||||
// siempre en movimiento.
|
||||
let arc = (std::f64::consts::PI * cam).sin();
|
||||
let pan_y = lerp(PAN_AMP_Y, -PAN_AMP_Y, cam) + arc * PAN_AMP_Y * 0.5;
|
||||
|
||||
let mut children: Vec<View<()>> = Vec::new();
|
||||
|
||||
if diorama_a > 0.001 {
|
||||
let plan = pan_plan(plan_for(snap, weights, scale), pan_x as f32, pan_y as f32);
|
||||
// Cull a viewport: a zoom alto recorta el grueso de los ~150k
|
||||
// polígonos fuera de cuadro y mantiene la escena liviana (clave para
|
||||
// que el GPU por software no wedgee a pantalla completa).
|
||||
let plan = cull_plan(plan, cw, ch, 64.0);
|
||||
let canvas = View::new(Style {
|
||||
position: Position::Absolute,
|
||||
inset: Rect {
|
||||
left: length(0.0),
|
||||
top: length(0.0),
|
||||
right: length(0.0),
|
||||
bottom: length(0.0),
|
||||
},
|
||||
size: Size { width: percent(1.0_f32), height: percent(1.0_f32) },
|
||||
..Default::default()
|
||||
})
|
||||
.alpha(diorama_a as f32)
|
||||
.children(vec![canvas_view::<()>(plan, None)]);
|
||||
children.push(canvas);
|
||||
}
|
||||
|
||||
// Viñeta sutil para asentar el diorama sobre el fondo negro.
|
||||
let vignette = {
|
||||
let [r, g, b, _] = bg.components;
|
||||
let edge = Color::new([r, g, b, 0.0]);
|
||||
let dark = Color::new([r * 0.3, g * 0.3, b * 0.3, 0.55]);
|
||||
View::new(Style {
|
||||
position: Position::Absolute,
|
||||
inset: Rect {
|
||||
left: length(0.0),
|
||||
top: length(0.0),
|
||||
right: length(0.0),
|
||||
bottom: length(0.0),
|
||||
},
|
||||
size: Size { width: percent(1.0_f32), height: percent(1.0_f32) },
|
||||
..Default::default()
|
||||
})
|
||||
.paint_with(move |scene, _ts, rect: PaintRect| {
|
||||
let cx = (rect.x + rect.w * 0.5) as f64;
|
||||
let cy = (rect.y + rect.h * 0.5) as f64;
|
||||
let radius = (rect.w.max(rect.h)) as f64 * 0.75;
|
||||
let grad = Gradient::new_radial(Point::new(cx, cy), radius as f32)
|
||||
.with_stops([edge, edge, dark].as_slice());
|
||||
scene.fill(
|
||||
peniko::Fill::NonZero,
|
||||
Affine::IDENTITY,
|
||||
&grad,
|
||||
None,
|
||||
&vello::kurbo::Rect::new(
|
||||
rect.x as f64,
|
||||
rect.y as f64,
|
||||
(rect.x + rect.w) as f64,
|
||||
(rect.y + rect.h) as f64,
|
||||
),
|
||||
);
|
||||
})
|
||||
};
|
||||
children.push(vignette);
|
||||
|
||||
// Overlay vector full-screen (cold-open + wordmark).
|
||||
let overlay = View::new(Style {
|
||||
position: Position::Absolute,
|
||||
inset: Rect {
|
||||
left: length(0.0),
|
||||
top: length(0.0),
|
||||
right: length(0.0),
|
||||
bottom: length(0.0),
|
||||
},
|
||||
size: Size { width: percent(1.0_f32), height: percent(1.0_f32) },
|
||||
..Default::default()
|
||||
})
|
||||
.paint_with(move |scene, ts, _rect: PaintRect| {
|
||||
draw_overlays(scene, ts, t, cw, ch);
|
||||
});
|
||||
children.push(overlay);
|
||||
|
||||
View::new(Style {
|
||||
size: Size { width: percent(1.0_f32), height: percent(1.0_f32) },
|
||||
position: Position::Relative,
|
||||
overflow: taffy::Point {
|
||||
x: taffy::Overflow::Hidden,
|
||||
y: taffy::Overflow::Hidden,
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.clip(true)
|
||||
.fill(bg)
|
||||
.children(children)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
rimay_localize::init();
|
||||
let mut args = std::env::args().skip(1);
|
||||
let out_dir = args
|
||||
.next()
|
||||
.unwrap_or_else(|| "showreel_frames_dominium".to_string());
|
||||
let n: usize = args.next().and_then(|v| v.parse().ok()).unwrap_or(300);
|
||||
let w: u32 = args.next().and_then(|v| v.parse().ok()).unwrap_or(1600);
|
||||
let h: u32 = args.next().and_then(|v| v.parse().ok()).unwrap_or(900);
|
||||
// Ventana de frames a renderar [start, end) — para chunkear el render en
|
||||
// varios procesos (el GPU por software del entorno wedgea tras ~18 frames
|
||||
// pesados en un mismo device; un proceso por chunk lo sortea). El `t` se
|
||||
// computa siempre contra `n`, así la ventana es un subconjunto del reel
|
||||
// completo, no un reel recortado. Default: todo.
|
||||
let start: usize = args.next().and_then(|v| v.parse().ok()).unwrap_or(0);
|
||||
let end: usize = args.next().and_then(|v| v.parse().ok()).unwrap_or(n).min(n);
|
||||
create_dir_all(&out_dir).expect("mkdir out_dir");
|
||||
|
||||
// Fondo: un negro azulado profundo, espacio negativo elegante.
|
||||
let bg = Color::from_rgba8(0x07, 0x09, 0x0B, 0xFF);
|
||||
let weights = demo_weights();
|
||||
|
||||
eprintln!("dominium_showreel: sembrando simulación y capturando {n} snapshots vivos…");
|
||||
let snaps = capture_snapshots(n);
|
||||
eprintln!(
|
||||
"dominium_showreel: pob inicial {} → final {} lemmings",
|
||||
snaps.first().map(|s| s.world.lemmings.len()).unwrap_or(0),
|
||||
snaps.last().map(|s| s.world.lemmings.len()).unwrap_or(0),
|
||||
);
|
||||
|
||||
// GPU: un device por proceso. El cuello de botella real del render
|
||||
// headless por software (llvmpipe) NO es el zoom sino el VOLUMEN de
|
||||
// geometría: la grilla de la app (240) emite ~150k polígonos y a 1600×900
|
||||
// satura el rasterizador hasta dejar frames negros/congelados. Por eso el
|
||||
// reel usa `SHOW_GRID` (120) + culling a viewport: con la escena liviana,
|
||||
// los 300 frames salen vivos en un solo proceso. Los args `start`/`end`
|
||||
// quedan disponibles por si hiciera falta chunkear en otro entorno.
|
||||
let hal = pollster::block_on(Hal::new(None)).expect("hal");
|
||||
let mut renderer = Renderer::new(&hal).expect("renderer");
|
||||
let target = make_target(&hal, w, h);
|
||||
let view = target.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
|
||||
let mut ts = Typesetter::new();
|
||||
let cw = w as f64;
|
||||
let ch = h as f64;
|
||||
let [br, bgc, bb, _] = bg.components;
|
||||
let base = Color::from_rgba8((br * 255.0) as u8, (bgc * 255.0) as u8, (bb * 255.0) as u8, 255);
|
||||
|
||||
for i in start..end {
|
||||
let t = if n <= 1 { 0.0 } else { i as f32 / (n as f32 - 1.0) };
|
||||
let root = build_view(t, cw, ch, &snaps, &weights, bg);
|
||||
|
||||
let mut layout = LayoutTree::new();
|
||||
let mounted = mount(&mut layout, root);
|
||||
let computed = {
|
||||
let tmap = &mounted.text_measures;
|
||||
layout
|
||||
.compute_with_measure(mounted.root, (w as f32, h as f32), |nid, known, avail| {
|
||||
match tmap.get(&nid) {
|
||||
Some(tm) => measure_text_node(&mut ts, tm, known, avail),
|
||||
None => taffy::Size::ZERO,
|
||||
}
|
||||
})
|
||||
.expect("layout")
|
||||
};
|
||||
let mut scene = vello::Scene::new();
|
||||
paint(&mut scene, &mounted, &computed, &mut ts, None, None);
|
||||
|
||||
renderer
|
||||
.render_to_view(&hal, &scene, &view, w, h, base)
|
||||
.expect("render_to_view");
|
||||
// Bloqueo explícito: que el trabajo de vello (compute + blit) termine
|
||||
// ANTES de copiar la textura. Sin esto, en el GPU por software del
|
||||
// entorno headless, escenas pesadas (zoom alto = polígonos grandes a
|
||||
// pantalla completa) dejaban el readback en frame congelado a partir
|
||||
// de cierto punto. Drenar la cola entre render y copia lo evita.
|
||||
let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
|
||||
let path = format!("{out_dir}/frame_{i:04}.png");
|
||||
write_png(&hal, &target, &path, w, h);
|
||||
if i % 30 == 0 || i == n - 1 {
|
||||
eprintln!("dominium_showreel: frame {}/{} (t={:.3})", i + 1, n, t);
|
||||
}
|
||||
}
|
||||
eprintln!("dominium_showreel: {n} frames en {out_dir}/ ({w}x{h})");
|
||||
}
|
||||
|
||||
/// Crea la textura destino del render (reusada dentro de un bloque de device).
|
||||
fn make_target(hal: &Hal, w: u32, h: u32) -> wgpu::Texture {
|
||||
hal.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: Some("dominium-showreel"),
|
||||
size: wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: FMT,
|
||||
usage: wgpu::TextureUsages::STORAGE_BINDING
|
||||
| wgpu::TextureUsages::RENDER_ATTACHMENT
|
||||
| wgpu::TextureUsages::COPY_SRC,
|
||||
view_formats: &[],
|
||||
})
|
||||
}
|
||||
|
||||
fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str, w: u32, h: u32) {
|
||||
let unpadded = (w * 4) as usize;
|
||||
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
|
||||
let padded = unpadded.div_ceil(align) * align;
|
||||
let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("readback"),
|
||||
size: (padded * h as usize) as u64,
|
||||
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let mut enc = hal
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
||||
enc.copy_texture_to_buffer(
|
||||
wgpu::TexelCopyTextureInfo {
|
||||
texture: target,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d::ZERO,
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
wgpu::TexelCopyBufferInfo {
|
||||
buffer: &buf,
|
||||
layout: wgpu::TexelCopyBufferLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(padded as u32),
|
||||
rows_per_image: Some(h),
|
||||
},
|
||||
},
|
||||
wgpu::Extent3d { width: w, height: h, depth_or_array_layers: 1 },
|
||||
);
|
||||
hal.queue.submit(std::iter::once(enc.finish()));
|
||||
let slice = buf.slice(..);
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
slice.map_async(wgpu::MapMode::Read, move |r| {
|
||||
let _ = tx.send(r);
|
||||
});
|
||||
let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
|
||||
rx.recv().unwrap().unwrap();
|
||||
let data = slice.get_mapped_range();
|
||||
let mut pixels = Vec::with_capacity((w * h * 4) as usize);
|
||||
for r in 0..h as usize {
|
||||
let s = r * padded;
|
||||
pixels.extend_from_slice(&data[s..s + unpadded]);
|
||||
}
|
||||
drop(data);
|
||||
buf.unmap();
|
||||
let file = File::create(path).expect("png");
|
||||
let mut enc = png::Encoder::new(BufWriter::new(file), w, h);
|
||||
enc.set_color(png::ColorType::Rgba);
|
||||
enc.set_depth(png::BitDepth::Eight);
|
||||
let mut wr = enc.write_header().unwrap();
|
||||
wr.write_image_data(&pixels).unwrap();
|
||||
}
|
||||
@@ -0,0 +1,357 @@
|
||||
//! Pantallazo headless de `dominium-app-llimphi` — el simulador de campo
|
||||
//! medio sobre Llimphi.
|
||||
//!
|
||||
//! Monta la **view real** de la app (menubar, status bar, banda de
|
||||
//! onboarding, canvas isométrico y panel lateral con el tab Mundo) con una
|
||||
//! simulación sembrada de verdad: el mismo `Sim` que usa la app, mundo
|
||||
//! 240×240 con biomas procedurales, 2500 lemmings y el pack de Conceptos
|
||||
//! por defecto (iglesia / banco / comuna / laboratorio…), avanzado unos
|
||||
//! cuantos ticks de `dominium-physics` para que el lienzo muestre una
|
||||
//! sociedad viva (población, acciones y métricas ψ reales en el panel).
|
||||
//!
|
||||
//! Pinta a una textura wgpu sin ventana y vuelca PNG (mismo patrón que
|
||||
//! `agora-app/examples/pantallazo_agora.rs`).
|
||||
//!
|
||||
//! `cargo run -p dominium-app-llimphi --example pantallazo_dominium --release -- [out.png]`
|
||||
#![allow(dead_code)]
|
||||
|
||||
// La app es un crate binario sin lib: incluimos sus módulos reales por
|
||||
// `#[path]` para llamar exactamente las mismas vistas que pinta la app.
|
||||
#[path = "../src/consts.rs"]
|
||||
mod consts;
|
||||
#[path = "../src/model.rs"]
|
||||
mod model;
|
||||
#[path = "../src/packs.rs"]
|
||||
mod packs;
|
||||
#[path = "../src/sim.rs"]
|
||||
mod sim;
|
||||
#[path = "../src/view.rs"]
|
||||
mod view;
|
||||
#[path = "../src/worldgen.rs"]
|
||||
mod worldgen;
|
||||
|
||||
use std::fs::File;
|
||||
use std::io::BufWriter;
|
||||
|
||||
use dominium_core::{PsiMetrics, SimParams, WorldStats};
|
||||
use dominium_iso::{IsoProjector, ZWeights};
|
||||
use dominium_render_plan::{build_plan_with_overrides, PlanConfig, RenderMode};
|
||||
use dominium_sim::Sim;
|
||||
use llimphi_motion::Tween;
|
||||
use llimphi_theme::Theme;
|
||||
use llimphi_ui::llimphi_hal::{wgpu, Hal};
|
||||
use llimphi_ui::llimphi_layout::taffy;
|
||||
use llimphi_ui::llimphi_layout::taffy::prelude::{
|
||||
length, percent, Dimension, FlexDirection, Size, Style,
|
||||
};
|
||||
use llimphi_ui::llimphi_layout::LayoutTree;
|
||||
use llimphi_ui::llimphi_raster::peniko::Color;
|
||||
use llimphi_ui::llimphi_raster::{vello, Renderer};
|
||||
use llimphi_ui::llimphi_text::Typesetter;
|
||||
use llimphi_ui::{measure_text_node, mount, paint, View};
|
||||
use llimphi_widget_menubar::{menubar_view, MenuBarSpec, DEFAULT_HEIGHT as MENU_H};
|
||||
use llimphi_widget_text_input::TextInputState;
|
||||
|
||||
use crate::consts::{GRID, KMEANS_REFRESH_TICKS, LEMMINGS, SNAPSHOT_RING_CAP, TICK_MS, TRAIL_CAP};
|
||||
use crate::model::{Model, Msg, PanelTab};
|
||||
use crate::packs::default_conceptos;
|
||||
use crate::sim::lemming_color_for;
|
||||
use crate::view::{canvas_pane, onboarding_bar, side_panel, status_bar};
|
||||
use crate::worldgen::bioma_palette;
|
||||
|
||||
const W: u32 = 1600;
|
||||
const H: u32 = 1000;
|
||||
const FMT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm;
|
||||
|
||||
/// Cuántos ticks de física avanzamos antes del pantallazo. Con la
|
||||
/// calibración de `init` la población **crece** (2500 → ~6300 en 15 ticks):
|
||||
/// hay actividad real (réplicas, extracciones, contadores de acciones) sin
|
||||
/// reventar el presupuesto de vello — el plan ya trae 57 600 celdas de
|
||||
/// terreno, y por encima de ~7000 lemmings extra el raster GPU desborda sus
|
||||
/// buffers internos y devuelve un frame vacío (verificado empíricamente:
|
||||
/// 20 ticks ≈ 7100 lemmings → PNG en blanco).
|
||||
const TICKS_SEMBRADOS: u64 = 15;
|
||||
|
||||
/// Construye el `Model` demo: el mismo estado que `Dominium::init`, pero
|
||||
/// con seeder determinista (pack embebido, sin leer el pack del usuario) y
|
||||
/// sin watcher de wawa-config — el pantallazo debe ser reproducible.
|
||||
fn modelo_demo() -> Model {
|
||||
// Calibración idéntica a `init` (src/main.rs): drenaje basal modesto,
|
||||
// réplica barata, regrowth limitado por la carga de la llanura.
|
||||
let params = SimParams {
|
||||
diffusion_rate: 0.02,
|
||||
entropy_rate: 0.004,
|
||||
regrowth_rate: 0.004,
|
||||
carrying_capacity: 40.0,
|
||||
metabolic_cost: 0.05,
|
||||
replicate_threshold: 28.0,
|
||||
child_energy_frac: 0.45,
|
||||
abundance_threshold: 50.0,
|
||||
..SimParams::default()
|
||||
};
|
||||
// Relieve por bioma (mares hunden, picos elevan) — calco de `init`.
|
||||
let weights = ZWeights {
|
||||
materia: 0.02,
|
||||
psique: -0.075,
|
||||
poder: 0.40,
|
||||
oro: 0.0,
|
||||
degradacion: 1.30,
|
||||
};
|
||||
|
||||
// Seeder determinista: mismo `worldgen::seed` del core que usa la app,
|
||||
// pero siempre con el pack embebido (el de `~/.config` cambiaría el
|
||||
// pantallazo según la máquina).
|
||||
let rng_seed = 0xD0_31_31_07;
|
||||
let seeder = |s: u64| dominium_core::worldgen::seed(s, GRID, LEMMINGS, default_conceptos());
|
||||
let mut sim = Sim::new(
|
||||
seeder(rng_seed),
|
||||
params,
|
||||
rng_seed,
|
||||
SNAPSHOT_RING_CAP,
|
||||
TRAIL_CAP,
|
||||
KMEANS_REFRESH_TICKS,
|
||||
true,
|
||||
Box::new(seeder),
|
||||
);
|
||||
|
||||
// Avanzamos la simulación de verdad: cada `advance` es un tick completo
|
||||
// de `dominium-physics` (mover/extraer/sincronizar/replicar/degradar…),
|
||||
// así el canvas y las métricas del panel muestran una sociedad viva.
|
||||
for _ in 0..TICKS_SEMBRADOS {
|
||||
sim.advance(false);
|
||||
}
|
||||
|
||||
Model {
|
||||
sim,
|
||||
// Misma cámara que la app: scale 3.0 px/celda, z_factor 0.55. En el
|
||||
// lienzo de 1600×1000 la maqueta iso 240×240 entra completa.
|
||||
iso: IsoProjector::new(3.0, 0.55),
|
||||
weights,
|
||||
cfg: PlanConfig {
|
||||
tile: 3.0,
|
||||
lemming_size: 2.6,
|
||||
lemming_lift: 0.6,
|
||||
concepto_size: 7.0,
|
||||
concepto_lift: 2.0,
|
||||
light_dir: (0.55, 0.35),
|
||||
andina_layers: 0,
|
||||
andina_threshold: 1.0,
|
||||
palette: bioma_palette(),
|
||||
render_mode: RenderMode::Composite,
|
||||
texture: false,
|
||||
},
|
||||
selected: None,
|
||||
sync_relieve: false,
|
||||
id_input: TextInputState::new(),
|
||||
id_input_focused: false,
|
||||
scenario_idx: 0,
|
||||
show_trails: false,
|
||||
theme: Theme::dark(),
|
||||
_wawa_watcher: None,
|
||||
panel_tab: PanelTab::Mundo,
|
||||
// `false` → la app muestra la banda de onboarding (primer arranque).
|
||||
onboarding_done: false,
|
||||
menu_open: None,
|
||||
menu_active: usize::MAX,
|
||||
menu_anim: Tween::idle(1.0),
|
||||
edit_menu: None,
|
||||
edit_active: usize::MAX,
|
||||
edit_anim: Tween::idle(1.0),
|
||||
clipboard: llimphi_clipboard::SystemClipboard::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Barra de menú con los mismos menús raíz que la app (`app_menu` en
|
||||
/// src/main.rs). Cerrados en el pantallazo, así que sólo se ven los rótulos.
|
||||
fn menu_demo() -> app_bus::AppMenu {
|
||||
use app_bus::{AppMenu, Menu, MenuItem};
|
||||
AppMenu::new()
|
||||
.menu(Menu::new("Archivo").item(MenuItem::new("Cargar pack de usuario", "file.loadpack")))
|
||||
.menu(Menu::new("Editar").item(MenuItem::new("Renombrar concepto…", "concepto.rename")))
|
||||
.menu(Menu::new("Simulación").item(MenuItem::new("Pausar", "sim.toggleplay")))
|
||||
.menu(Menu::new("Ver").item(MenuItem::new("Ciclar modo de render", "view.rendermode")))
|
||||
.menu(Menu::new("Ayuda").item(MenuItem::new("Mostrar guía de uso", "help.onboarding")))
|
||||
}
|
||||
|
||||
/// Misma composición que `Dominium::view` (src/main.rs): menubar + status
|
||||
/// bar + banda de onboarding + fila canvas|panel. Sólo se omiten los
|
||||
/// handlers de click/drag del canvas — acá nadie interactúa.
|
||||
fn view_demo(model: &Model, menu: &app_bus::AppMenu, theme: &Theme) -> View<Msg> {
|
||||
let shown = model.sim.displayed_world();
|
||||
let stats = WorldStats::from_world(shown);
|
||||
let psi_metrics = PsiMetrics::from_world(shown);
|
||||
|
||||
let status = status_bar(model, theme);
|
||||
let plan = build_plan_with_overrides(shown, &model.iso, &model.weights, &model.cfg, |i| {
|
||||
lemming_color_for(model, i)
|
||||
});
|
||||
let canvas = canvas_pane(plan);
|
||||
let side = side_panel(model, &stats, &psi_metrics, theme);
|
||||
|
||||
let body = View::new(Style {
|
||||
flex_direction: FlexDirection::Row,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: Dimension::auto(),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
min_size: Size {
|
||||
width: length(0.0_f32),
|
||||
height: length(0.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.children(vec![canvas, side]);
|
||||
|
||||
let menubar = menubar_view(&MenuBarSpec {
|
||||
menu,
|
||||
open: model.menu_open,
|
||||
theme,
|
||||
viewport: (W as f32, H as f32),
|
||||
height: MENU_H,
|
||||
on_open: std::sync::Arc::new(Msg::MenuOpen),
|
||||
on_command: std::sync::Arc::new(|c: &str| Msg::MenuCommand(c.to_string())),
|
||||
});
|
||||
|
||||
let mut frame: Vec<View<Msg>> = vec![menubar, status];
|
||||
if !model.onboarding_done {
|
||||
frame.push(onboarding_bar(theme));
|
||||
}
|
||||
frame.push(body);
|
||||
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Column,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.fill(theme.bg_app)
|
||||
.children(frame)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
rimay_localize::init();
|
||||
let out = std::env::args()
|
||||
.nth(1)
|
||||
.unwrap_or_else(|| "/tmp/shots/dominium.png".to_string());
|
||||
if let Some(dir) = std::path::Path::new(&out).parent() {
|
||||
std::fs::create_dir_all(dir).ok();
|
||||
}
|
||||
|
||||
let theme = Theme::dark();
|
||||
let model = modelo_demo();
|
||||
eprintln!(
|
||||
"pantallazo_dominium: mundo {GRID}×{GRID} · pob {} · tick {} (cada tick = {TICK_MS} ms en la app)",
|
||||
model.sim.world.lemmings.len(),
|
||||
model.sim.tick,
|
||||
);
|
||||
let menu = menu_demo();
|
||||
let root = view_demo(&model, &menu, &theme);
|
||||
|
||||
// view → layout → scene (misma secuencia que el eventloop real).
|
||||
let mut layout = LayoutTree::new();
|
||||
let mounted = mount(&mut layout, root);
|
||||
let mut ts = Typesetter::new();
|
||||
let computed = {
|
||||
let tmap = &mounted.text_measures;
|
||||
layout
|
||||
.compute_with_measure(mounted.root, (W as f32, H as f32), |nid, known, avail| {
|
||||
match tmap.get(&nid) {
|
||||
Some(tm) => measure_text_node(&mut ts, tm, known, avail),
|
||||
None => taffy::Size::ZERO,
|
||||
}
|
||||
})
|
||||
.expect("layout")
|
||||
};
|
||||
let mut scene = vello::Scene::new();
|
||||
paint(&mut scene, &mounted, &computed, &mut ts, None, None);
|
||||
|
||||
let hal = pollster::block_on(Hal::new(None)).expect("hal");
|
||||
let mut renderer = Renderer::new(&hal).expect("renderer");
|
||||
let target = hal.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: Some("pantallazo-dominium"),
|
||||
size: wgpu::Extent3d {
|
||||
width: W,
|
||||
height: H,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: FMT,
|
||||
usage: wgpu::TextureUsages::STORAGE_BINDING
|
||||
| wgpu::TextureUsages::RENDER_ATTACHMENT
|
||||
| wgpu::TextureUsages::COPY_SRC,
|
||||
view_formats: &[],
|
||||
});
|
||||
let view = target.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
let [r, g, b, _] = theme.bg_app.components;
|
||||
let bg = Color::from_rgba8((r * 255.0) as u8, (g * 255.0) as u8, (b * 255.0) as u8, 255);
|
||||
renderer
|
||||
.render_to_view(&hal, &scene, &view, W, H, bg)
|
||||
.expect("render_to_view");
|
||||
|
||||
write_png(&hal, &target, &out);
|
||||
eprintln!("pantallazo_dominium: escrito {out} ({W}x{H})");
|
||||
}
|
||||
|
||||
/// Lee la textura a CPU y la vuelca como PNG RGBA8.
|
||||
fn write_png(hal: &Hal, target: &wgpu::Texture, path: &str) {
|
||||
let unpadded = (W * 4) as usize;
|
||||
let align = wgpu::COPY_BYTES_PER_ROW_ALIGNMENT as usize;
|
||||
let padded = unpadded.div_ceil(align) * align;
|
||||
let buf = hal.device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("readback"),
|
||||
size: (padded * H as usize) as u64,
|
||||
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
let mut enc = hal
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
|
||||
enc.copy_texture_to_buffer(
|
||||
wgpu::TexelCopyTextureInfo {
|
||||
texture: target,
|
||||
mip_level: 0,
|
||||
origin: wgpu::Origin3d::ZERO,
|
||||
aspect: wgpu::TextureAspect::All,
|
||||
},
|
||||
wgpu::TexelCopyBufferInfo {
|
||||
buffer: &buf,
|
||||
layout: wgpu::TexelCopyBufferLayout {
|
||||
offset: 0,
|
||||
bytes_per_row: Some(padded as u32),
|
||||
rows_per_image: Some(H),
|
||||
},
|
||||
},
|
||||
wgpu::Extent3d {
|
||||
width: W,
|
||||
height: H,
|
||||
depth_or_array_layers: 1,
|
||||
},
|
||||
);
|
||||
hal.queue.submit(std::iter::once(enc.finish()));
|
||||
let slice = buf.slice(..);
|
||||
let (tx, rx) = std::sync::mpsc::channel();
|
||||
slice.map_async(wgpu::MapMode::Read, move |r| {
|
||||
let _ = tx.send(r);
|
||||
});
|
||||
let _ = hal.device.poll(wgpu::PollType::wait_indefinitely());
|
||||
rx.recv().unwrap().unwrap();
|
||||
let data = slice.get_mapped_range();
|
||||
let mut pixels = Vec::with_capacity((W * H * 4) as usize);
|
||||
for row in 0..H as usize {
|
||||
let s = row * padded;
|
||||
pixels.extend_from_slice(&data[s..s + unpadded]);
|
||||
}
|
||||
drop(data);
|
||||
buf.unmap();
|
||||
let file = File::create(path).expect("png");
|
||||
let mut enc = png::Encoder::new(BufWriter::new(file), W, H);
|
||||
enc.set_color(png::ColorType::Rgba);
|
||||
enc.set_depth(png::BitDepth::Eight);
|
||||
let mut w = enc.write_header().unwrap();
|
||||
w.write_image_data(&pixels).unwrap();
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": "templo-andino",
|
||||
"sprite_id": 8,
|
||||
"pos_x": 40.0,
|
||||
"pos_y": 12.0,
|
||||
"radius": 14.0,
|
||||
"mods": { "materia": 0.10, "psique": 0.35, "poder": -0.05, "oro": 0.02 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 22.0 }, "forced_action": 2, "duration": 60 }
|
||||
},
|
||||
{
|
||||
"id": "ayllu-norte",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 16.0,
|
||||
"pos_y": 28.0,
|
||||
"radius": 14.0,
|
||||
"mods": { "materia": 0.25, "psique": 0.08, "poder": -0.12, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 14.0 }, "forced_action": 3, "duration": 35 }
|
||||
},
|
||||
{
|
||||
"id": "ayllu-sur",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 62.0,
|
||||
"pos_y": 56.0,
|
||||
"radius": 14.0,
|
||||
"mods": { "materia": 0.25, "psique": 0.08, "poder": -0.12, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 14.0 }, "forced_action": 3, "duration": 35 }
|
||||
},
|
||||
{
|
||||
"id": "mina-de-altura",
|
||||
"sprite_id": 7,
|
||||
"pos_x": 12.0,
|
||||
"pos_y": 68.0,
|
||||
"radius": 8.0,
|
||||
"mods": { "materia": -0.10, "psique": -0.03, "poder": 0.05, "oro": 0.18 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 30 }
|
||||
},
|
||||
{
|
||||
"id": "tambo",
|
||||
"sprite_id": 5,
|
||||
"pos_x": 40.0,
|
||||
"pos_y": 44.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": 0.08, "psique": 0.05, "poder": 0.02, "oro": 0.05 },
|
||||
"hack": { "trigger": "Always", "forced_action": 3, "duration": 22 }
|
||||
},
|
||||
{
|
||||
"id": "ayllu-este",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 68.0,
|
||||
"pos_y": 22.0,
|
||||
"radius": 12.0,
|
||||
"mods": { "materia": 0.22, "psique": 0.06, "poder": -0.10, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 14.0 }, "forced_action": 3, "duration": 35 }
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": "reserva-federal",
|
||||
"sprite_id": 2,
|
||||
"pos_x": 40.0,
|
||||
"pos_y": 16.0,
|
||||
"radius": 18.0,
|
||||
"mods": { "materia": 0.00, "psique": -0.06, "poder": 0.40, "oro": -0.20 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 30 }
|
||||
},
|
||||
{
|
||||
"id": "broker-norte",
|
||||
"sprite_id": 2,
|
||||
"pos_x": 64.0,
|
||||
"pos_y": 24.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": -0.04, "psique": 0.05, "poder": 0.10, "oro": 0.15 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 20 }
|
||||
},
|
||||
{
|
||||
"id": "broker-sur",
|
||||
"sprite_id": 2,
|
||||
"pos_x": 16.0,
|
||||
"pos_y": 56.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": -0.04, "psique": 0.05, "poder": 0.10, "oro": 0.15 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 20 }
|
||||
},
|
||||
{
|
||||
"id": "casino-vip",
|
||||
"sprite_id": 6,
|
||||
"pos_x": 16.0,
|
||||
"pos_y": 32.0,
|
||||
"radius": 8.0,
|
||||
"mods": { "materia": -0.06, "psique": 0.12, "poder": -0.02, "oro": 0.25 },
|
||||
"hack": { "trigger": "Always", "forced_action": 1, "duration": 14 }
|
||||
},
|
||||
{
|
||||
"id": "mall",
|
||||
"sprite_id": 7,
|
||||
"pos_x": 28.0,
|
||||
"pos_y": 56.0,
|
||||
"radius": 13.0,
|
||||
"mods": { "materia": 0.04, "psique": 0.10, "poder": 0.02, "oro": 0.10 },
|
||||
"hack": { "trigger": "Always", "forced_action": 3, "duration": 14 }
|
||||
},
|
||||
{
|
||||
"id": "agencia-de-prensa",
|
||||
"sprite_id": 4,
|
||||
"pos_x": 56.0,
|
||||
"pos_y": 56.0,
|
||||
"radius": 13.0,
|
||||
"mods": { "materia": -0.02, "psique": 0.35, "poder": 0.05, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EdadSobre": 40 }, "forced_action": 2, "duration": 25 }
|
||||
},
|
||||
{
|
||||
"id": "barriada",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 12.0,
|
||||
"pos_y": 68.0,
|
||||
"radius": 11.0,
|
||||
"mods": { "materia": 0.10, "psique": -0.05, "poder": -0.15, "oro": -0.05 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 8.0 }, "forced_action": 3, "duration": 25 }
|
||||
},
|
||||
{
|
||||
"id": "barriada-norte",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 70.0,
|
||||
"pos_y": 8.0,
|
||||
"radius": 10.0,
|
||||
"mods": { "materia": 0.10, "psique": -0.05, "poder": -0.15, "oro": -0.05 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 8.0 }, "forced_action": 3, "duration": 25 }
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
{
|
||||
"items": [
|
||||
{
|
||||
"id": "zigurat",
|
||||
"sprite_id": 1,
|
||||
"pos_x": 36.0,
|
||||
"pos_y": 24.0,
|
||||
"radius": 12.0,
|
||||
"mods": { "materia": -0.04, "psique": 0.32, "poder": 0.18, "oro": 0.00 },
|
||||
"hack": { "trigger": { "EnergiaBajo": 20.0 }, "forced_action": 2, "duration": 45 }
|
||||
},
|
||||
{
|
||||
"id": "palacio",
|
||||
"sprite_id": 5,
|
||||
"pos_x": 52.0,
|
||||
"pos_y": 20.0,
|
||||
"radius": 11.0,
|
||||
"mods": { "materia": -0.06, "psique": -0.02, "poder": 0.38, "oro": 0.08 },
|
||||
"hack": { "trigger": { "EdadSobre": 50 }, "forced_action": 5, "duration": 25 }
|
||||
},
|
||||
{
|
||||
"id": "bazar",
|
||||
"sprite_id": 7,
|
||||
"pos_x": 28.0,
|
||||
"pos_y": 48.0,
|
||||
"radius": 12.0,
|
||||
"mods": { "materia": 0.06, "psique": 0.04, "poder": 0.00, "oro": 0.10 },
|
||||
"hack": { "trigger": "Always", "forced_action": 3, "duration": 18 }
|
||||
},
|
||||
{
|
||||
"id": "campo-de-cebada",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 16.0,
|
||||
"pos_y": 64.0,
|
||||
"radius": 14.0,
|
||||
"mods": { "materia": 0.22, "psique": 0.02, "poder": -0.06, "oro": 0.00 },
|
||||
"hack": null
|
||||
},
|
||||
{
|
||||
"id": "casa-de-tablillas",
|
||||
"sprite_id": 4,
|
||||
"pos_x": 62.0,
|
||||
"pos_y": 60.0,
|
||||
"radius": 9.0,
|
||||
"mods": { "materia": -0.02, "psique": 0.18, "poder": 0.10, "oro": 0.02 },
|
||||
"hack": { "trigger": { "EdadSobre": 70 }, "forced_action": 2, "duration": 30 }
|
||||
},
|
||||
{
|
||||
"id": "irrigacion",
|
||||
"sprite_id": 3,
|
||||
"pos_x": 48.0,
|
||||
"pos_y": 50.0,
|
||||
"radius": 10.0,
|
||||
"mods": { "materia": 0.16, "psique": 0.00, "poder": -0.02, "oro": 0.00 },
|
||||
"hack": null
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
//! Constantes de mundo y de bucle compartidas por todos los módulos de la app.
|
||||
|
||||
/// Lado de la grilla cuadrada del mundo. 240×240 = 57 600 celdas: continente
|
||||
/// con varios biomas (mares, ríos, llanuras, sierras, picos). El motor sigue
|
||||
/// siendo O(grid) en difusión y O(N²) en `nearest`, así que la población
|
||||
/// arranca en miles pero limitada por los frenos termodinámicos de
|
||||
/// `init`-time (ver `SimParams` override).
|
||||
pub(crate) const GRID: usize = 240;
|
||||
/// Población inicial de Lemmings. Miles. La densidad efectiva queda más
|
||||
/// baja que en la versión 80² histórica (≈0.043 lem/celda) porque sólo
|
||||
/// spawnean en tierra navegable y el motor ya no permite el crecimiento
|
||||
/// exponencial sin freno.
|
||||
pub(crate) const LEMMINGS: usize = 2500;
|
||||
/// Periodo del bucle de simulación (~11 Hz).
|
||||
pub(crate) const TICK_MS: u64 = 90;
|
||||
/// Cada cuántos ticks recalculamos k-means para colorear los clusters
|
||||
/// (modo PsiCluster). 30 ticks ≈ 2.7s — suficiente para ver tribus
|
||||
/// emergentes sin que el costo del kmeans (O(K·N·iter)) note.
|
||||
pub(crate) const KMEANS_REFRESH_TICKS: u64 = 30;
|
||||
/// Ancho del panel de stats.
|
||||
pub(crate) const SIDE_WIDTH: f32 = 240.0;
|
||||
|
||||
/// Tamaño del ring de snapshots: ~18 segundos a 11 Hz. Permite ver hacia
|
||||
/// atrás un par de minutos de simulación sin pasarse en RAM (cada snapshot
|
||||
/// es un `World` clonado; con grid 40×40 y ~50 lemmings, ~30 KB).
|
||||
pub(crate) const SNAPSHOT_RING_CAP: usize = 200;
|
||||
/// Largo del trail por lemming. Tradeoff: muy alto y la pantalla se llena
|
||||
/// de motas; muy bajo y el rastro no cuenta nada. 24 a 11 Hz ≈ 2 s de
|
||||
/// historia visible — coincide con el horizonte que el ojo integra.
|
||||
pub(crate) const TRAIL_CAP: usize = 24;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,312 @@
|
||||
//! Modelo de la app y mensajes del bucle Elm. La conducta vive en
|
||||
//! `update`/`view` (en `main.rs`); acá sólo los datos y los enums de edición.
|
||||
|
||||
use dominium_iso::{IsoProjector, ZWeights};
|
||||
use dominium_sim::Sim;
|
||||
use dominium_render_plan::PlanConfig;
|
||||
use llimphi_theme::Theme;
|
||||
use llimphi_clipboard::SystemClipboard;
|
||||
use llimphi_ui::KeyEvent;
|
||||
use llimphi_widget_edit_menu::EditAction;
|
||||
use llimphi_widget_text_input::TextInputState;
|
||||
|
||||
pub(crate) struct Model {
|
||||
/// Sesión de simulación (estado de dominio + reloj + historia): `world`,
|
||||
/// `params`, `tick/epoch/rng_seed`, ring de snapshots (rewind), trails y
|
||||
/// clusters. El ciclo de vida (`advance`/`reseed`/…) vive en `Sim`
|
||||
/// (`dominium-sim`); el `Model` sólo guarda estado de vista.
|
||||
pub(crate) sim: Sim,
|
||||
pub(crate) iso: IsoProjector,
|
||||
pub(crate) weights: ZWeights,
|
||||
pub(crate) cfg: PlanConfig,
|
||||
/// Índice del Concepto seleccionado, si alguno. `None` cuando no hay
|
||||
/// selección. Si se "Limpia" la lista se resetea a `None`.
|
||||
pub(crate) selected: Option<usize>,
|
||||
/// Cuando está activo, editar `ZWeights` (relieve visual) también
|
||||
/// escribe a `params.relieve` (relieve físico) — lo que ves es lo
|
||||
/// que sienten los lemmings.
|
||||
pub(crate) sync_relieve: bool,
|
||||
/// Buffer de texto del input de renombre. `id_input_focused` decide
|
||||
/// si el panel muestra el text-input o el label estático.
|
||||
pub(crate) id_input: TextInputState,
|
||||
pub(crate) id_input_focused: bool,
|
||||
/// Índice del scenario actual en `scenario_packs()`. El picker del panel
|
||||
/// lo cicla; "Sembrar pack" instala el JSON correspondiente.
|
||||
pub(crate) scenario_idx: usize,
|
||||
/// Toggle para mostrar las trayectorias.
|
||||
pub(crate) show_trails: bool,
|
||||
/// Theme efectivo. Se construye en init desde `wawa-config` (con
|
||||
/// fallback a `Theme::dark()` si no hay archivo aún) y se rearma
|
||||
/// en cada `Msg::WawaConfigChanged`.
|
||||
pub(crate) theme: Theme,
|
||||
/// Subscripción al bus de configuración del SO. `Option` porque
|
||||
/// la creación puede fallar en plataformas sin ProjectDirs.
|
||||
/// Se mantiene viva mientras vive el `Model`.
|
||||
pub(crate) _wawa_watcher: Option<wawa_config::ConfigWatcher>,
|
||||
/// Cuál tab del panel lateral está activo. La UI muestra los grupos
|
||||
/// relevantes según esta selección — el modelo es simple, sin lazy load.
|
||||
pub(crate) panel_tab: PanelTab,
|
||||
/// Si el usuario ya entendió las gestures de canvas (click crea, drag
|
||||
/// mueve, segundo click selecciona). Cuando es `false` la app muestra
|
||||
/// un hint flotante sobre el canvas. Se apaga al primer click.
|
||||
pub(crate) onboarding_done: bool,
|
||||
/// Barra de menú principal: índice del menú raíz abierto (`None` cerrado).
|
||||
pub(crate) menu_open: Option<usize>,
|
||||
/// Fila resaltada por teclado en el menú principal (`usize::MAX` = ninguna).
|
||||
pub(crate) menu_active: usize,
|
||||
/// Animación de aparición/swap del dropdown del menú principal (0→1).
|
||||
pub(crate) menu_anim: llimphi_motion::Tween<f32>,
|
||||
/// Menú de edición contextual: ancla `(x, y)` en ventana (`None` cerrado).
|
||||
/// Opera sobre el editor del campo de texto focuseado (`id_input`).
|
||||
pub(crate) edit_menu: Option<(f32, f32)>,
|
||||
/// Fila resaltada por teclado en el menú de edición (`usize::MAX` = ninguna).
|
||||
pub(crate) edit_active: usize,
|
||||
/// Animación de aparición del menú de edición (0→1).
|
||||
pub(crate) edit_anim: llimphi_motion::Tween<f32>,
|
||||
/// Clipboard del sistema, compartido por el menú de edición y el
|
||||
/// text-input de renombre.
|
||||
pub(crate) clipboard: SystemClipboard,
|
||||
}
|
||||
|
||||
/// Pestañas del panel lateral. El orden es el orden visual en el tab bar.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
pub(crate) enum PanelTab {
|
||||
Mundo,
|
||||
Conceptos,
|
||||
Psique,
|
||||
Vista,
|
||||
}
|
||||
|
||||
impl PanelTab {
|
||||
pub(crate) fn label(self) -> &'static str {
|
||||
match self {
|
||||
PanelTab::Mundo => "Mundo",
|
||||
PanelTab::Conceptos => "Conceptos",
|
||||
PanelTab::Psique => "ψ",
|
||||
PanelTab::Vista => "Vista",
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) fn all() -> [PanelTab; 4] {
|
||||
[
|
||||
PanelTab::Mundo,
|
||||
PanelTab::Conceptos,
|
||||
PanelTab::Psique,
|
||||
PanelTab::Vista,
|
||||
]
|
||||
}
|
||||
}
|
||||
|
||||
/// Una de las cuatro capas modificables de un `Concepto` (degradacion
|
||||
/// queda fuera — es cicatriz emergente, no editable).
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) enum Layer {
|
||||
Materia,
|
||||
Psique,
|
||||
Poder,
|
||||
Oro,
|
||||
}
|
||||
|
||||
/// Slot de `SimParams` editable desde el panel. Los 4 más visibles más los
|
||||
/// dos del ciclo estacional; los demás quedan al default.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) enum ParamSlot {
|
||||
ClimbCost,
|
||||
DiffusionRate,
|
||||
EntropyRate,
|
||||
MoveCost,
|
||||
SeasonPeriod,
|
||||
SeasonAmplitude,
|
||||
/// Intensidad con la que el psi modula los efectos de las acciones.
|
||||
PsiModulation,
|
||||
/// Radio social del contagio (Fase B).
|
||||
SocialRadius,
|
||||
/// Tasa de convergencia del contagio social.
|
||||
ContagionRate,
|
||||
/// Umbral de homofilia (Fase B.2) — 0 = sin filtro.
|
||||
HomophilyThreshold,
|
||||
// — Economía: los levers termodinámicos del flujo de energía. Deciden
|
||||
// si una población crece, se estabiliza o colapsa. Hasta ahora
|
||||
// hardcoded; expuestos para que el escenario guardado los capture.
|
||||
/// Cantidad de materia que `Extraer` drena del suelo por acción.
|
||||
ExtractRate,
|
||||
/// Energía transferida por `Intercambiar`.
|
||||
TradeAmount,
|
||||
/// Fracción del espacio libre que la naturaleza repuebla por tick.
|
||||
RegrowthRate,
|
||||
/// Asíntota del regrowth: techo de materia por celda.
|
||||
CarryingCapacity,
|
||||
/// Drenaje basal de energía por tick a todo lemming vivo.
|
||||
MetabolicCost,
|
||||
/// Umbral de energía para que `Replicar` dispare.
|
||||
ReplicateThreshold,
|
||||
/// Umbral de abundancia por encima del cual el agente se fuerza a
|
||||
/// `Replicar` (0 = desactiva la transición).
|
||||
AbundanceThreshold,
|
||||
// — Cinética fina: los escalares de cada acción atómica y del ciclo de
|
||||
// vida. Más quirúrgicos que la economía; tunean la "sensación" del
|
||||
// motor sin redefinir su balance macro.
|
||||
/// Celdas por tick que avanza `Mover`.
|
||||
MoveSpeed,
|
||||
/// Tasa de convergencia del `vector_psi` en `Sincronizar` (0-1).
|
||||
SyncRate,
|
||||
/// Degradación añadida al suelo por cada `Extraer`.
|
||||
DegrPerExtract,
|
||||
/// Fracción de la energía del padre que hereda el hijo en `Replicar`.
|
||||
ChildEnergyFrac,
|
||||
/// Daño de energía que inflige `Degradar`.
|
||||
FightDamage,
|
||||
/// Fracción del daño que el atacante absorbe como energía.
|
||||
AbsorbFrac,
|
||||
/// Umbral de energía bajo el cual el agente se fuerza a `Degradar`.
|
||||
DesperationThreshold,
|
||||
/// Edad máxima; al superarla el agente muere (entero, en ticks).
|
||||
MaxEdad,
|
||||
}
|
||||
|
||||
impl ParamSlot {
|
||||
pub(crate) fn range(self) -> (f32, f32) {
|
||||
match self {
|
||||
ParamSlot::ClimbCost => (0.0, 0.5),
|
||||
ParamSlot::DiffusionRate => (0.0, 0.5),
|
||||
ParamSlot::EntropyRate => (0.0, 0.05),
|
||||
ParamSlot::MoveCost => (0.0, 0.5),
|
||||
// 0 = sin estaciones; hasta 500 ticks por ciclo (≈45 s a 11 Hz).
|
||||
ParamSlot::SeasonPeriod => (0.0, 500.0),
|
||||
ParamSlot::SeasonAmplitude => (0.0, 1.0),
|
||||
// Psi modulation: rango [0, 1] de uso típico; > 1 amplifica
|
||||
// demasiado y rompe calibraciones del default.
|
||||
ParamSlot::PsiModulation => (0.0, 1.0),
|
||||
// Radio social — hasta media diagonal del grid 80×80.
|
||||
ParamSlot::SocialRadius => (0.0, 30.0),
|
||||
// Tasa de contagio: > 0.5 produce conformismo brutal en pocos
|
||||
// ticks; típicos 0.05..0.20.
|
||||
ParamSlot::ContagionRate => (0.0, 0.5),
|
||||
// Homofilia 0..2 — > sqrt(4) = 2 incluye todo el psi space.
|
||||
ParamSlot::HomophilyThreshold => (0.0, 2.0),
|
||||
// Economía — rangos calibrados alrededor de los defaults del
|
||||
// motor (ver `SimParams::default` / overrides de init).
|
||||
ParamSlot::ExtractRate => (0.0, 6.0),
|
||||
ParamSlot::TradeAmount => (0.0, 5.0),
|
||||
ParamSlot::RegrowthRate => (0.0, 0.1),
|
||||
ParamSlot::CarryingCapacity => (0.0, 100.0),
|
||||
ParamSlot::MetabolicCost => (0.0, 0.5),
|
||||
ParamSlot::ReplicateThreshold => (0.0, 100.0),
|
||||
ParamSlot::AbundanceThreshold => (0.0, 150.0),
|
||||
// Cinética fina — rangos alrededor de los defaults del motor.
|
||||
ParamSlot::MoveSpeed => (0.0, 4.0),
|
||||
ParamSlot::SyncRate => (0.0, 1.0),
|
||||
ParamSlot::DegrPerExtract => (0.0, 0.2),
|
||||
ParamSlot::ChildEnergyFrac => (0.0, 1.0),
|
||||
ParamSlot::FightDamage => (0.0, 20.0),
|
||||
ParamSlot::AbsorbFrac => (0.0, 1.0),
|
||||
ParamSlot::DesperationThreshold => (0.0, 30.0),
|
||||
// Edad máxima en ticks — 0 = inmortal (cuidado: sin cosecha por
|
||||
// vejez la población sólo cae por desesperación/metabolismo).
|
||||
ParamSlot::MaxEdad => (0.0, 20000.0),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Capa de `ZWeights` editable desde el panel — define el **relieve
|
||||
/// visual** (cuánto eleva cada capa el render). Independiente del
|
||||
/// `relieve` físico de `SimParams`.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub(crate) enum ZSlot {
|
||||
Materia,
|
||||
Psique,
|
||||
Poder,
|
||||
Oro,
|
||||
Degradacion,
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub(crate) enum Msg {
|
||||
Tick,
|
||||
TogglePlay,
|
||||
Reseed,
|
||||
LimpiarConceptos,
|
||||
SembrarConceptos,
|
||||
SelectConcepto(usize),
|
||||
DeselectConcepto,
|
||||
EditMod(Layer, f32),
|
||||
EditRadius(f32),
|
||||
DeleteSelected,
|
||||
EditParam(ParamSlot, f32),
|
||||
EditZWeight(ZSlot, f32),
|
||||
GuardarPack,
|
||||
CargarPack,
|
||||
CrearConcepto,
|
||||
/// Click sobre el canvas, en coords de mundo. Si cae sobre un
|
||||
/// Concepto existente lo selecciona; si no, crea uno nuevo ahí.
|
||||
CanvasClick(f32, f32),
|
||||
ToggleSyncRelieve,
|
||||
ToggleAndina,
|
||||
// Editor de BehaviorHack del Concepto seleccionado.
|
||||
HackToggle, // agrega o quita el hack.
|
||||
HackCycleTrigger, // rota Always → EnergiaBajo → EdadSobre → Always.
|
||||
HackCycleAction, // rota la acción forzada 0..5 → 0...
|
||||
HackEditTriggerParam(f32),
|
||||
HackEditDuration(f32),
|
||||
CycleSprite,
|
||||
/// Delta de un Move dentro de un drag activo, en coords de mundo.
|
||||
/// Mueve el Concepto seleccionado si hay uno.
|
||||
CanvasDragMove(f32, f32),
|
||||
FocusIdInput,
|
||||
BlurIdInput,
|
||||
IdInputKey(KeyEvent),
|
||||
/// Cicla al siguiente scenario embebido. Sólo cambia la selección
|
||||
/// (no lo aplica hasta que se toque "Cargar scenario").
|
||||
CycleScenario,
|
||||
/// Reemplaza los conceptos del mundo con el scenario actualmente
|
||||
/// seleccionado. Limpia hack_locks vivos y deselecciona.
|
||||
LoadScenario,
|
||||
/// Cicla `cfg.render_mode`: Composite → Heatmap(Materia) → … →
|
||||
/// Heatmap(Degradacion) → Composite.
|
||||
CycleRenderMode,
|
||||
/// Toggle de visualización de trayectorias.
|
||||
ToggleTrails,
|
||||
/// Toggle de texturización procedural sobre los techos.
|
||||
ToggleTexture,
|
||||
/// Delta sobre `rewind_offset` (positivo = más atrás; negativo = hacia
|
||||
/// el presente). El slider del panel emite estos deltas; un botón
|
||||
/// "vivo" emite `RewindHome`.
|
||||
RewindBy(f32),
|
||||
/// Vuelve `rewind_offset` a 0 (presente).
|
||||
RewindHome,
|
||||
/// El bus `wawa-config` publicó una versión nueva. Aplicamos
|
||||
/// theme y locale; los demás campos no nos competen.
|
||||
WawaConfigChanged(Box<wawa_config::WawaConfig>),
|
||||
/// Alterna `big_five` en SimParams. Si la población vino sin columna
|
||||
/// `psi5` (saves Big Four), la rellenamos al pasar a Big5.
|
||||
ToggleBigFive,
|
||||
/// Cicla `ActionPolicy` entre Fixed y PsiArgmax. Con periodo 0 nunca
|
||||
/// re-elige, así que también arrancamos un período sano la primera vez.
|
||||
CyclePsiPolicy,
|
||||
/// Cambia el tab activo del panel lateral.
|
||||
SelectTab(PanelTab),
|
||||
/// Cierra el hint flotante de onboarding (se cierra solo en el primer
|
||||
/// click sobre el canvas, pero también hay una X visible).
|
||||
DismissOnboarding,
|
||||
/// Barra de menú principal: abrir/cerrar un menú raíz (`None` = cerrar).
|
||||
MenuOpen(Option<usize>),
|
||||
/// Comando elegido en el menú principal — se traduce al `Msg` real.
|
||||
MenuCommand(String),
|
||||
/// Navegación por teclado en el menú principal (`+1` baja, `-1` sube).
|
||||
MenuNav(i32),
|
||||
/// Enter en el menú principal: ejecuta la fila activa.
|
||||
MenuActivate,
|
||||
/// Tick de animación de menús (sólo re-render).
|
||||
MenuTick,
|
||||
/// Navegación por teclado en el menú de edición.
|
||||
EditNav(i32),
|
||||
/// Enter en el menú de edición: ejecuta la fila activa.
|
||||
EditActivate,
|
||||
/// Right-click en la ventana → abre el menú de edición en `(x, y)`,
|
||||
/// operando sobre el campo de texto focuseado (`id_input`).
|
||||
EditMenuOpen(f32, f32),
|
||||
/// Acción elegida en el menú de edición (sobre `id_input`).
|
||||
EditMenuAction(EditAction),
|
||||
/// Cierra cualquier menú abierto (click-fuera / Esc).
|
||||
CloseMenus,
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
//! Packs de Conceptos: scenarios embebidos en el binario y persistencia del
|
||||
//! pack del usuario en `$XDG_CONFIG_HOME/dominium/pack.json`.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use dominium_core::{Conceptos, SimParams};
|
||||
use dominium_iso::ZWeights;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
/// Pack JSON por defecto — iglesia / banco / comuna / laboratorio + variantes.
|
||||
/// Embebido para que el binario corra sin archivos sueltos en cwd.
|
||||
pub(crate) const DEFAULT_PACK: &str = include_str!("../conceptos.default.json");
|
||||
/// Scenarios embebidos: civilizaciones-arquetipo. Cada uno es un JSON con
|
||||
/// la misma forma que el `DEFAULT_PACK`; el picker del panel cicla entre
|
||||
/// ellos sin necesidad de archivos sueltos.
|
||||
pub(crate) const PACK_ANDES: &str = include_str!("../packs/andes.json");
|
||||
pub(crate) const PACK_MESOPOTAMIA: &str = include_str!("../packs/mesopotamia.json");
|
||||
pub(crate) const PACK_CAPITALISMO: &str = include_str!("../packs/capitalismo.json");
|
||||
|
||||
/// Parsea el pack JSON embebido. Si el JSON está malformado el binario
|
||||
/// arranca con la colección vacía — la sim corre igual.
|
||||
pub(crate) fn default_conceptos() -> Conceptos {
|
||||
serde_json::from_str::<Conceptos>(DEFAULT_PACK).unwrap_or_default()
|
||||
}
|
||||
|
||||
/// Listado ordenado de packs embebidos disponibles en el picker. El primero
|
||||
/// es el default; el ciclo es circular. Tupla `(id legible, JSON raw)`.
|
||||
pub(crate) fn scenario_packs() -> [(&'static str, &'static str); 4] {
|
||||
[
|
||||
("default", DEFAULT_PACK),
|
||||
("andes", PACK_ANDES),
|
||||
("mesopotamia", PACK_MESOPOTAMIA),
|
||||
("capitalismo", PACK_CAPITALISMO),
|
||||
]
|
||||
}
|
||||
|
||||
/// Path absoluto al pack del usuario: `$XDG_CONFIG_HOME/dominium/pack.json`
|
||||
/// (típicamente `~/.config/dominium/pack.json`). `None` si la plataforma
|
||||
/// no expone un config dir.
|
||||
pub(crate) fn user_pack_path() -> Option<PathBuf> {
|
||||
directories::ProjectDirs::from("", "", "dominium")
|
||||
.map(|d| d.config_dir().join("pack.json"))
|
||||
}
|
||||
|
||||
/// Escenario completo serializable: la termodinámica del motor
|
||||
/// (`params`), el relieve visual (`weights`) y los Conceptos del mundo, en
|
||||
/// un solo archivo reproducible. Es el "pack" en su forma rica — guardar y
|
||||
/// cargar restituye el mundo *y su sintonía*, no sólo las fichas.
|
||||
///
|
||||
/// `params` y `weights` son `Option` para que un pack viejo (sólo
|
||||
/// `Conceptos`) cargue sin ellos y la app conserve su sintonía actual. La
|
||||
/// retrocompatibilidad la garantiza [`parse_escenario`], no el `#[serde]`.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
pub(crate) struct Escenario {
|
||||
/// Sintonía del motor. `None` = no tocar los `SimParams` vigentes.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub params: Option<SimParams>,
|
||||
/// Relieve visual (`ZWeights`). `None` = no tocar el relieve vigente.
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub weights: Option<ZWeights>,
|
||||
/// Las fichas del mundo. Siempre presente (puede ir vacío).
|
||||
#[serde(default)]
|
||||
pub conceptos: Conceptos,
|
||||
}
|
||||
|
||||
/// Parsea un JSON de pack tolerando los dos formatos:
|
||||
/// 1. **Escenario rico** `{ "params": …, "weights": …, "conceptos": {…} }`.
|
||||
/// 2. **Pack histórico** `{ "items": [ … ] }` — sólo `Conceptos`, sin
|
||||
/// sintonía; se envuelve en un `Escenario` con `params`/`weights` a
|
||||
/// `None`.
|
||||
///
|
||||
/// El discriminante es la clave `conceptos`: si está, es formato rico; si
|
||||
/// no, se intenta como `Conceptos` plano.
|
||||
fn parse_escenario(raw: &str) -> Option<Escenario> {
|
||||
if raw.contains("\"conceptos\"") {
|
||||
match serde_json::from_str::<Escenario>(raw) {
|
||||
Ok(esc) => return Some(esc),
|
||||
Err(e) => eprintln!("dominium · escenario malformado: {e}"),
|
||||
}
|
||||
}
|
||||
match serde_json::from_str::<Conceptos>(raw) {
|
||||
Ok(conceptos) => Some(Escenario {
|
||||
params: None,
|
||||
weights: None,
|
||||
conceptos,
|
||||
}),
|
||||
Err(e) => {
|
||||
eprintln!("dominium · pack corrupto: {e}");
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Escribe el escenario completo (sintonía + relieve + Conceptos) al pack
|
||||
/// del usuario. Crea el directorio padre si no existe. Errores van a
|
||||
/// stderr (la app no muere).
|
||||
pub(crate) fn save_user_escenario(params: &SimParams, weights: &ZWeights, cs: &Conceptos) {
|
||||
let Some(path) = user_pack_path() else {
|
||||
eprintln!("dominium · no hay ProjectDirs en esta plataforma");
|
||||
return;
|
||||
};
|
||||
if let Some(parent) = path.parent() {
|
||||
if let Err(e) = std::fs::create_dir_all(parent) {
|
||||
eprintln!("dominium · no pude crear {}: {e}", parent.display());
|
||||
return;
|
||||
}
|
||||
}
|
||||
let esc = Escenario {
|
||||
params: Some(params.clone()),
|
||||
weights: Some(*weights),
|
||||
conceptos: cs.clone(),
|
||||
};
|
||||
match serde_json::to_string_pretty(&esc) {
|
||||
Ok(json) => match std::fs::write(&path, json) {
|
||||
Ok(()) => eprintln!("dominium · escenario guardado en {}", path.display()),
|
||||
Err(e) => eprintln!("dominium · error escribiendo {}: {e}", path.display()),
|
||||
},
|
||||
Err(e) => eprintln!("dominium · error serializando escenario: {e}"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Carga el escenario del usuario si existe. Devuelve `None` si el archivo
|
||||
/// no está, o si el contenido no parsea por ninguno de los dos formatos.
|
||||
pub(crate) fn load_user_escenario() -> Option<Escenario> {
|
||||
let path = user_pack_path()?;
|
||||
let raw = std::fs::read_to_string(&path).ok()?;
|
||||
let esc = parse_escenario(&raw)?;
|
||||
eprintln!("dominium · escenario cargado desde {}", path.display());
|
||||
Some(esc)
|
||||
}
|
||||
|
||||
/// Carga sólo los Conceptos del pack del usuario — vista estrecha sobre
|
||||
/// [`load_user_escenario`] para el seeder del mundo (que no toca params).
|
||||
pub(crate) fn load_user_pack() -> Option<Conceptos> {
|
||||
load_user_escenario().map(|e| e.conceptos)
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
//! Helpers de mutación/render que tocan estado de VISTA además del dominio.
|
||||
//! El ciclo de vida de la simulación (avance, reseed, snapshots, trails,
|
||||
//! clusters) vive en `dominium_sim::Sim` (regla #2); acá quedan los que
|
||||
//! cruzan con `selected`, `cfg`, `iso` u otros campos del frontend.
|
||||
|
||||
use dominium_core::{Concepto, LayerMods};
|
||||
use dominium_render_plan::{Color, Quad, RenderMode, RenderPlan};
|
||||
|
||||
use crate::consts::GRID;
|
||||
use crate::model::Model;
|
||||
|
||||
/// Accede mutable al Concepto seleccionado, si lo hay.
|
||||
pub(crate) fn selected_mut(m: &mut Model) -> Option<&mut Concepto> {
|
||||
let i = m.selected?;
|
||||
m.sim.world.conceptos.items.get_mut(i)
|
||||
}
|
||||
|
||||
/// Agrega un Concepto en `(x, y)` (clamp al grid), lo nombra
|
||||
/// `nuevo-N` y queda seleccionado para edición inmediata.
|
||||
pub(crate) fn spawn_concepto_at(m: &mut Model, x: f32, y: f32) {
|
||||
let max = (GRID as f32) - 1.0;
|
||||
let n = m.sim.world.conceptos.len();
|
||||
let new = Concepto {
|
||||
id: format!("nuevo-{}", n + 1),
|
||||
sprite_id: 0,
|
||||
pos_x: x.clamp(0.0, max),
|
||||
pos_y: y.clamp(0.0, max),
|
||||
radius: 4.0,
|
||||
mods: LayerMods::default(),
|
||||
hack: None,
|
||||
persuasion: None,
|
||||
};
|
||||
let i = m.sim.world.conceptos.add(new);
|
||||
m.selected = Some(i);
|
||||
}
|
||||
|
||||
/// Copia `ZWeights` (relieve visual) al array `[f32; 5]` que SimParams
|
||||
/// usa como relieve físico, manteniendo el orden de capas del `Grid`.
|
||||
pub(crate) fn mirror_zweights_to_relieve(
|
||||
z: &dominium_iso::ZWeights,
|
||||
relieve: &mut [f32; 5],
|
||||
) {
|
||||
relieve[dominium_core::RELIEVE_MATERIA] = z.materia;
|
||||
relieve[dominium_core::RELIEVE_PSIQUE] = z.psique;
|
||||
relieve[dominium_core::RELIEVE_PODER] = z.poder;
|
||||
relieve[dominium_core::RELIEVE_ORO] = z.oro;
|
||||
relieve[dominium_core::RELIEVE_DEGRADACION] = z.degradacion;
|
||||
}
|
||||
|
||||
/// Tres colores fijos del paleta de clusters — orden de aparición en el
|
||||
/// resultado de `kmeans_psi`. Magenta / cian / amarillo: los más fáciles de
|
||||
/// distinguir sobre cualquier fondo de bioma.
|
||||
pub(crate) const CLUSTER_COLORS: [Color; 3] = [
|
||||
[0.96, 0.30, 0.72, 1.0], // magenta
|
||||
[0.30, 0.90, 0.90, 1.0], // cian
|
||||
[0.96, 0.92, 0.30, 1.0], // amarillo
|
||||
];
|
||||
|
||||
/// Color para el lemming `i` según el `RenderMode` actual y las
|
||||
/// asignaciones de cluster vigentes. Se usa como override de
|
||||
/// `build_plan_with_overrides`.
|
||||
pub(crate) fn lemming_color_for(m: &Model, i: usize) -> Color {
|
||||
if matches!(m.cfg.render_mode, RenderMode::PsiCluster)
|
||||
&& i < m.sim.cluster_assignments.len()
|
||||
{
|
||||
let c = m.sim.cluster_assignments[i] as usize;
|
||||
if c < CLUSTER_COLORS.len() {
|
||||
return CLUSTER_COLORS[c];
|
||||
}
|
||||
}
|
||||
m.cfg.palette.lemming
|
||||
}
|
||||
|
||||
/// Pinta las posiciones históricas de los lemmings como quads diminutos
|
||||
/// con alpha decreciente — los más viejos casi transparentes. Va después
|
||||
/// del `build_plan` para que los trails queden por encima del suelo pero
|
||||
/// por debajo del HUD; depth pequeño constante negativo para no romper el
|
||||
/// orden de pintor de las celdas.
|
||||
///
|
||||
/// Se llama sólo en vivo (no en rewind), porque en rewind el `World` que
|
||||
/// se renderiza no necesariamente tiene los mismos índices de lemming que
|
||||
/// el frame de trails — y mezclarlos confundiría al ojo más que ayudar.
|
||||
pub(crate) fn overlay_trails(plan: &mut RenderPlan, m: &Model) {
|
||||
let n_frames = m.sim.trails.len();
|
||||
if n_frames == 0 {
|
||||
return;
|
||||
}
|
||||
let lemming_color = m.cfg.palette.lemming;
|
||||
// Tamaño de la moteta: la mitad del marker del lemming, así no compite
|
||||
// visualmente con la posición actual.
|
||||
let size = m.cfg.lemming_size * 0.45;
|
||||
for (k, frame) in m.sim.trails.iter().enumerate() {
|
||||
// k=0 es el más viejo → alpha bajo; k=n-1 el más nuevo → alpha alto.
|
||||
// No incluyo el último frame: ya está pintado por el lemming actual.
|
||||
if k + 1 == n_frames {
|
||||
break;
|
||||
}
|
||||
let t = (k + 1) as f32 / n_frames as f32; // ∈ (0, 1)
|
||||
let alpha = 0.10 + 0.40 * t;
|
||||
let color: Color = [
|
||||
lemming_color[0],
|
||||
lemming_color[1],
|
||||
lemming_color[2],
|
||||
alpha,
|
||||
];
|
||||
for &(x, y) in frame {
|
||||
let (sx, sy) = m.iso.project(x, y, m.cfg.lemming_lift * 0.5);
|
||||
plan.quads.push(Quad {
|
||||
x: sx - size * 0.5,
|
||||
y: sy - size * 0.5,
|
||||
w: size,
|
||||
h: size,
|
||||
color,
|
||||
// Detrás de los Lemmings vivos (que pintan a depth ≈ x+y+0.5)
|
||||
// pero delante de la celda (depth x+y).
|
||||
depth: x + y + 0.25,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Mantengo el plan ordenado: insert al final desordena. Re-ordeno por
|
||||
// depth — coste O(N log N) pero N es del orden de 50·24 = 1200 quads.
|
||||
plan.quads.sort_by(|a, b| {
|
||||
a.depth.partial_cmp(&b.depth).unwrap_or(std::cmp::Ordering::Equal)
|
||||
});
|
||||
// Re-extender la bounding box por si los trails caen fuera.
|
||||
for q in &plan.quads {
|
||||
plan.min_x = plan.min_x.min(q.x);
|
||||
plan.min_y = plan.min_y.min(q.y);
|
||||
plan.max_x = plan.max_x.max(q.x + q.w);
|
||||
plan.max_y = plan.max_y.max(q.y + q.h);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,992 @@
|
||||
//! Todas las vistas de la app: status bar, onboarding, canvas pane, panel
|
||||
//! lateral con sus cuatro tabs y los widgets de fila/slider reutilizados.
|
||||
|
||||
use dominium_canvas_llimphi::canvas_view;
|
||||
use dominium_core::{Epoch, PsiMetrics, Trigger, WorldStats};
|
||||
use dominium_render_plan::{Color, RenderMode};
|
||||
use llimphi_theme::Theme;
|
||||
use llimphi_ui::llimphi_layout::taffy::{
|
||||
prelude::{length, percent, Dimension, FlexDirection, Size, Style},
|
||||
AlignItems, JustifyContent, Rect,
|
||||
};
|
||||
use llimphi_ui::llimphi_text::Alignment;
|
||||
use llimphi_ui::{DragPhase, View};
|
||||
use llimphi_widget_button::{button_view, ButtonPalette};
|
||||
use llimphi_widget_slider::{slider_view, SliderPalette};
|
||||
use llimphi_widget_text_input::{text_input_view, TextInputPalette};
|
||||
|
||||
use crate::consts::{GRID, SIDE_WIDTH};
|
||||
use crate::model::{Layer, Model, Msg, PanelTab, ParamSlot, ZSlot};
|
||||
use crate::packs::scenario_packs;
|
||||
use crate::sim::CLUSTER_COLORS;
|
||||
|
||||
/// Nombre humano de la acción atómica `0..5`.
|
||||
fn action_name(b: u8) -> &'static str {
|
||||
match b {
|
||||
0 => "Mover",
|
||||
1 => "Extraer",
|
||||
2 => "Sincronizar",
|
||||
3 => "Intercambiar",
|
||||
4 => "Replicar",
|
||||
5 => "Degradar",
|
||||
_ => "?",
|
||||
}
|
||||
}
|
||||
|
||||
/// Descripción del trigger para mostrar en el panel.
|
||||
fn trigger_label(t: Trigger) -> String {
|
||||
match t {
|
||||
Trigger::Always => "Always".to_string(),
|
||||
Trigger::EnergiaBajo(v) => format!("EnergíaBajo({v:.0})"),
|
||||
Trigger::EdadSobre(v) => format!("EdadSobre({v})"),
|
||||
}
|
||||
}
|
||||
|
||||
/// Banda informativa que cubre el ancho de la app y explica las tres
|
||||
/// gestures básicas del canvas. Se muestra hasta que el usuario haga el
|
||||
/// primer click (que también es la gesture más obvia). Tiene una X a la
|
||||
/// derecha para cerrarla manualmente sin tocar el canvas.
|
||||
pub(crate) fn onboarding_bar(theme: &Theme) -> View<Msg> {
|
||||
let hint_text = "Click vacío → crea concepto · Click sobre uno → selecciona · Drag → mover · Tabs arriba a la derecha";
|
||||
let label = View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(hint_text, 11.5, theme.accent, Alignment::Start);
|
||||
let close_btn = View::new(Style {
|
||||
size: Size {
|
||||
width: length(28.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_shrink: 0.0,
|
||||
..Default::default()
|
||||
})
|
||||
.children(vec![llimphi_widget_button::button_view::<Msg>(
|
||||
"✕",
|
||||
&ButtonPalette::from_theme(theme),
|
||||
Msg::DismissOnboarding,
|
||||
)]);
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Row,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(28.0_f32),
|
||||
},
|
||||
align_items: Some(AlignItems::Center),
|
||||
padding: Rect {
|
||||
left: length(14.0_f32),
|
||||
right: length(6.0_f32),
|
||||
top: length(0.0_f32),
|
||||
bottom: length(0.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.fill(theme.bg_panel)
|
||||
.children(vec![label, close_btn])
|
||||
}
|
||||
|
||||
pub(crate) fn status_bar(model: &Model, theme: &Theme) -> View<Msg> {
|
||||
let estado = rimay_localize::t(if model.sim.running {
|
||||
"dominium-status-running"
|
||||
} else {
|
||||
"dominium-status-paused"
|
||||
});
|
||||
// Texto principal: tamaño · población · epoch · tick. El usuario lo
|
||||
// ve siempre, sin importar el tab del panel.
|
||||
let line = format!(
|
||||
"{}×{} · pob {} · epoch {} · tick {}",
|
||||
GRID,
|
||||
GRID,
|
||||
model.sim.world.lemmings.len(),
|
||||
model.sim.epoch,
|
||||
model.sim.tick,
|
||||
);
|
||||
let label_view = View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(line, 12.0, theme.fg_text, Alignment::Start);
|
||||
let estado_view = View::new(Style {
|
||||
size: Size {
|
||||
width: length(120.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(estado, 12.0, theme.accent, Alignment::End);
|
||||
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Row,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(34.0_f32),
|
||||
},
|
||||
align_items: Some(AlignItems::Center),
|
||||
justify_content: Some(JustifyContent::SpaceBetween),
|
||||
padding: Rect {
|
||||
left: length(14.0_f32),
|
||||
right: length(14.0_f32),
|
||||
top: length(0.0_f32),
|
||||
bottom: length(0.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.fill(theme.bg_panel)
|
||||
.children(vec![label_view, estado_view])
|
||||
}
|
||||
|
||||
pub(crate) fn canvas_pane(plan: dominium_render_plan::RenderPlan) -> View<Msg> {
|
||||
let canvas_bg = llimphi_ui::llimphi_raster::peniko::Color::from_rgba8(11, 13, 18, 255);
|
||||
let canvas = canvas_view::<Msg>(plan, Some(canvas_bg));
|
||||
View::new(Style {
|
||||
size: Size {
|
||||
width: Dimension::auto(),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
flex_basis: length(0.0_f32),
|
||||
min_size: Size {
|
||||
width: length(0.0_f32),
|
||||
height: length(0.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.clip(true)
|
||||
.children(vec![canvas])
|
||||
}
|
||||
|
||||
pub(crate) fn side_panel(
|
||||
model: &Model,
|
||||
stats: &WorldStats,
|
||||
psi_metrics: &PsiMetrics,
|
||||
theme: &Theme,
|
||||
) -> View<Msg> {
|
||||
let btn_palette = ButtonPalette::from_theme(theme);
|
||||
let mut slider_palette = SliderPalette::from_theme(theme);
|
||||
// Comprimimos los slots para que entren en el sidebar de 240 px.
|
||||
slider_palette.label_width = 56.0;
|
||||
slider_palette.track_width = 90.0;
|
||||
slider_palette.value_width = 44.0;
|
||||
|
||||
let header = label_view(&rimay_localize::t("dominium-header-sim"), 11.0, theme.fg_muted);
|
||||
|
||||
let play_label = rimay_localize::t(if model.sim.running {
|
||||
"dominium-btn-pause"
|
||||
} else {
|
||||
"dominium-btn-resume"
|
||||
});
|
||||
let play_btn = sized_button(&play_label, &btn_palette, Msg::TogglePlay);
|
||||
let reset_btn = sized_button(
|
||||
&rimay_localize::t("dominium-btn-reseed"),
|
||||
&btn_palette,
|
||||
Msg::Reseed,
|
||||
);
|
||||
|
||||
// --- Tab bar: 4 pestañas chiquitas en fila ---
|
||||
let tab_bar = tab_bar_view(model, &btn_palette, theme);
|
||||
|
||||
// Header siempre visible: play/pause + reseed (los controles más usados,
|
||||
// independientes del tab).
|
||||
let mut children: Vec<View<Msg>> = vec![
|
||||
header,
|
||||
tab_bar,
|
||||
play_btn,
|
||||
reset_btn,
|
||||
separator(theme),
|
||||
];
|
||||
|
||||
// Contenido específico del tab actual.
|
||||
match model.panel_tab {
|
||||
PanelTab::Mundo => append_mundo_tab(&mut children, model, stats, theme, &btn_palette, &slider_palette),
|
||||
PanelTab::Conceptos => append_conceptos_tab(&mut children, model, theme, &btn_palette, &slider_palette),
|
||||
PanelTab::Psique => append_psique_tab(&mut children, model, stats, psi_metrics, theme, &btn_palette, &slider_palette),
|
||||
PanelTab::Vista => append_vista_tab(&mut children, model, theme, &btn_palette, &slider_palette),
|
||||
}
|
||||
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Column,
|
||||
size: Size {
|
||||
width: length(SIDE_WIDTH),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_shrink: 0.0,
|
||||
gap: Size {
|
||||
width: length(0.0_f32),
|
||||
height: length(10.0_f32),
|
||||
},
|
||||
padding: Rect {
|
||||
left: length(14.0_f32),
|
||||
right: length(14.0_f32),
|
||||
top: length(14.0_f32),
|
||||
bottom: length(14.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.fill(theme.bg_panel)
|
||||
.children(children)
|
||||
}
|
||||
|
||||
/// Línea horizontal de 1 px usada como separator entre secciones del panel.
|
||||
fn separator(theme: &Theme) -> View<Msg> {
|
||||
View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(1.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.fill(theme.border)
|
||||
}
|
||||
|
||||
/// Barra horizontal con un botón por cada `PanelTab`. El tab activo se
|
||||
/// resalta cambiando el `accent` del label (botón) — la palette de Llimphi
|
||||
/// no expone "tab pill", así que usamos la convención de marcar el activo
|
||||
/// con `▸`.
|
||||
fn tab_bar_view(model: &Model, btn_palette: &ButtonPalette, _theme: &Theme) -> View<Msg> {
|
||||
let buttons: Vec<View<Msg>> = PanelTab::all()
|
||||
.into_iter()
|
||||
.map(|tab| {
|
||||
let active = tab == model.panel_tab;
|
||||
let label = if active {
|
||||
format!("▸ {}", tab.label())
|
||||
} else {
|
||||
tab.label().to_string()
|
||||
};
|
||||
let mut bp = btn_palette.clone();
|
||||
if active {
|
||||
bp.bg = btn_palette.bg_hover;
|
||||
}
|
||||
View::new(Style {
|
||||
size: Size {
|
||||
width: Dimension::auto(),
|
||||
height: length(26.0_f32),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
flex_basis: length(0.0_f32),
|
||||
..Default::default()
|
||||
})
|
||||
.children(vec![llimphi_widget_button::button_view::<Msg>(
|
||||
&label,
|
||||
&bp,
|
||||
Msg::SelectTab(tab),
|
||||
)])
|
||||
})
|
||||
.collect();
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Row,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(26.0_f32),
|
||||
},
|
||||
gap: Size {
|
||||
width: length(4.0_f32),
|
||||
height: length(0.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.children(buttons)
|
||||
}
|
||||
|
||||
/// Tab "Mundo" — estado macro + sliders de motor + scenario picker.
|
||||
fn append_mundo_tab(
|
||||
children: &mut Vec<View<Msg>>,
|
||||
model: &Model,
|
||||
stats: &WorldStats,
|
||||
theme: &Theme,
|
||||
btn_palette: &ButtonPalette,
|
||||
slider_palette: &SliderPalette,
|
||||
) {
|
||||
children.push(label_view(
|
||||
&rimay_localize::t("dominium-header-metricas"),
|
||||
11.0,
|
||||
theme.fg_muted,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-population"),
|
||||
&stats.n.to_string(),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-epoca"),
|
||||
Epoch::classify(stats).label(),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-materia"),
|
||||
&format!("{:.0}", stats.total_materia),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-oro"),
|
||||
&format!("{:.0}", stats.total_oro),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-energia"),
|
||||
&format!("{:.0}", stats.total_energia),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-gini-energia"),
|
||||
&format!("{:.3}", stats.gini_energia),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-edad-media"),
|
||||
&format!("{:.1}", stats.mean_edad),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
"season×",
|
||||
&format!("{:.2}", model.sim.params.season_factor(model.sim.world.tick_count)),
|
||||
theme,
|
||||
));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ ACCIONES ACTUALES ]", 11.0, theme.fg_muted));
|
||||
let action_labels: [(&str, usize); 6] = [
|
||||
("dominium-action-mover", 0),
|
||||
("dominium-action-extraer", 1),
|
||||
("dominium-action-sincronizar", 2),
|
||||
("dominium-action-intercambiar", 3),
|
||||
("dominium-action-replicar", 4),
|
||||
("dominium-action-degradar", 5),
|
||||
];
|
||||
for (key, ai) in action_labels {
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t(key),
|
||||
&stats.action_counts[ai].to_string(),
|
||||
theme,
|
||||
));
|
||||
}
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ MOTOR ]", 11.0, theme.fg_muted));
|
||||
children.push(param_slider("climb", model.sim.params.climb_cost, ParamSlot::ClimbCost, slider_palette));
|
||||
children.push(param_slider("move", model.sim.params.move_cost, ParamSlot::MoveCost, slider_palette));
|
||||
children.push(param_slider("diffuse", model.sim.params.diffusion_rate, ParamSlot::DiffusionRate, slider_palette));
|
||||
children.push(param_slider("entropy", model.sim.params.entropy_rate, ParamSlot::EntropyRate, slider_palette));
|
||||
children.push(param_slider("season T", model.sim.params.season_period as f32, ParamSlot::SeasonPeriod, slider_palette));
|
||||
children.push(param_slider("season A", model.sim.params.season_amplitude, ParamSlot::SeasonAmplitude, slider_palette));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ ECONOMÍA ]", 11.0, theme.fg_muted));
|
||||
children.push(param_slider("extraer", model.sim.params.extract_rate, ParamSlot::ExtractRate, slider_palette));
|
||||
children.push(param_slider("trueque", model.sim.params.trade_amount, ParamSlot::TradeAmount, slider_palette));
|
||||
children.push(param_slider("regrowth", model.sim.params.regrowth_rate, ParamSlot::RegrowthRate, slider_palette));
|
||||
children.push(param_slider("carga", model.sim.params.carrying_capacity, ParamSlot::CarryingCapacity, slider_palette));
|
||||
children.push(param_slider("metabol", model.sim.params.metabolic_cost, ParamSlot::MetabolicCost, slider_palette));
|
||||
children.push(param_slider("replica", model.sim.params.replicate_threshold, ParamSlot::ReplicateThreshold, slider_palette));
|
||||
children.push(param_slider("abundan", model.sim.params.abundance_threshold, ParamSlot::AbundanceThreshold, slider_palette));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ CINÉTICA ]", 11.0, theme.fg_muted));
|
||||
children.push(param_slider("velocid", model.sim.params.move_speed, ParamSlot::MoveSpeed, slider_palette));
|
||||
children.push(param_slider("sync", model.sim.params.sync_rate, ParamSlot::SyncRate, slider_palette));
|
||||
children.push(param_slider("cicatriz", model.sim.params.degr_per_extract, ParamSlot::DegrPerExtract, slider_palette));
|
||||
children.push(param_slider("herencia", model.sim.params.child_energy_frac, ParamSlot::ChildEnergyFrac, slider_palette));
|
||||
children.push(param_slider("daño", model.sim.params.fight_damage, ParamSlot::FightDamage, slider_palette));
|
||||
children.push(param_slider("absorbe", model.sim.params.absorb_frac, ParamSlot::AbsorbFrac, slider_palette));
|
||||
children.push(param_slider("desespe", model.sim.params.desperation_threshold, ParamSlot::DesperationThreshold, slider_palette));
|
||||
children.push(param_slider("edad max", model.sim.params.max_edad as f32, ParamSlot::MaxEdad, slider_palette));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ SCENARIO ]", 11.0, theme.fg_muted));
|
||||
let packs = scenario_packs();
|
||||
let (current_id, _) = packs[model.scenario_idx];
|
||||
children.push(sized_button(
|
||||
&format!("pack: {} (▸ ciclar)", current_id),
|
||||
btn_palette,
|
||||
Msg::CycleScenario,
|
||||
));
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t_args("dominium-btn-load-named", &[("name", current_id.into())]),
|
||||
btn_palette,
|
||||
Msg::LoadScenario,
|
||||
));
|
||||
children.push(separator(theme));
|
||||
children.push(label_view(&format!("grilla {GRID}×{GRID}"), 11.0, theme.fg_muted));
|
||||
}
|
||||
|
||||
/// Tab "Conceptos" — lista de conceptos, crear/cargar/guardar/limpiar,
|
||||
/// y el editor del Concepto seleccionado (radius, sprite, 4 mods, hack).
|
||||
fn append_conceptos_tab(
|
||||
children: &mut Vec<View<Msg>>,
|
||||
model: &Model,
|
||||
theme: &Theme,
|
||||
btn_palette: &ButtonPalette,
|
||||
slider_palette: &SliderPalette,
|
||||
) {
|
||||
children.push(label_view(
|
||||
&rimay_localize::t("dominium-header-conceptos"),
|
||||
11.0,
|
||||
theme.fg_muted,
|
||||
));
|
||||
children.push(label_view(
|
||||
&rimay_localize::t_args(
|
||||
"dominium-active-count",
|
||||
&[("count", model.sim.world.conceptos.len().to_string().into())],
|
||||
),
|
||||
12.0,
|
||||
theme.fg_text,
|
||||
));
|
||||
|
||||
// Hint contextual: si no hay conceptos, le decimos cómo crear uno.
|
||||
if model.sim.world.conceptos.items.is_empty() {
|
||||
children.push(label_view(
|
||||
"Click sobre el mapa para crear",
|
||||
11.0,
|
||||
theme.fg_muted,
|
||||
));
|
||||
}
|
||||
|
||||
for (i, c) in model.sim.world.conceptos.items.iter().enumerate() {
|
||||
children.push(concepto_row(i, &c.id, model.selected == Some(i), theme));
|
||||
}
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t("dominium-btn-create-concept"),
|
||||
btn_palette,
|
||||
Msg::CrearConcepto,
|
||||
));
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t("dominium-btn-seed-pack"),
|
||||
btn_palette,
|
||||
Msg::SembrarConceptos,
|
||||
));
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t("dominium-btn-clear"),
|
||||
btn_palette,
|
||||
Msg::LimpiarConceptos,
|
||||
));
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t("dominium-btn-save"),
|
||||
btn_palette,
|
||||
Msg::GuardarPack,
|
||||
));
|
||||
children.push(sized_button(
|
||||
&rimay_localize::t("dominium-btn-load-saved"),
|
||||
btn_palette,
|
||||
Msg::CargarPack,
|
||||
));
|
||||
|
||||
// Editor del seleccionado.
|
||||
let Some(i) = model.selected else { return };
|
||||
let Some(c) = model.sim.world.conceptos.items.get(i) else { return };
|
||||
children.push(separator(theme));
|
||||
children.push(label_view(
|
||||
&rimay_localize::t("dominium-header-editar"),
|
||||
11.0,
|
||||
theme.fg_muted,
|
||||
));
|
||||
if model.id_input_focused {
|
||||
children.push(text_input_view(
|
||||
&model.id_input,
|
||||
&rimay_localize::t("dominium-slider-nombre"),
|
||||
true,
|
||||
&TextInputPalette::from_theme(theme),
|
||||
Msg::FocusIdInput,
|
||||
));
|
||||
} else {
|
||||
children.push(sized_button(
|
||||
&format!("• {} (✎ renombrar)", c.id),
|
||||
btn_palette,
|
||||
Msg::FocusIdInput,
|
||||
));
|
||||
}
|
||||
children.push(slider_view(
|
||||
&rimay_localize::t("dominium-slider-radius"),
|
||||
c.radius,
|
||||
0.5,
|
||||
20.0,
|
||||
slider_palette,
|
||||
|phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::EditRadius(dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
));
|
||||
children.push(sized_button(
|
||||
&format!(
|
||||
"sprite: {} ({})",
|
||||
c.sprite_id,
|
||||
dominium_render_plan::sprite_name(c.sprite_id)
|
||||
),
|
||||
btn_palette,
|
||||
Msg::CycleSprite,
|
||||
));
|
||||
children.push(mod_slider(
|
||||
&rimay_localize::t("dominium-slider-materia"),
|
||||
c.mods.materia,
|
||||
Layer::Materia,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(mod_slider(
|
||||
&rimay_localize::t("dominium-slider-psique"),
|
||||
c.mods.psique,
|
||||
Layer::Psique,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(mod_slider(
|
||||
&rimay_localize::t("dominium-slider-poder"),
|
||||
c.mods.poder,
|
||||
Layer::Poder,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(mod_slider(
|
||||
&rimay_localize::t("dominium-slider-oro"),
|
||||
c.mods.oro,
|
||||
Layer::Oro,
|
||||
slider_palette,
|
||||
));
|
||||
|
||||
children.push(label_view(
|
||||
&rimay_localize::t("dominium-label-hack"),
|
||||
11.0,
|
||||
theme.fg_muted,
|
||||
));
|
||||
match c.hack {
|
||||
None => {
|
||||
children.push(sized_button(
|
||||
"+ Agregar hack",
|
||||
btn_palette,
|
||||
Msg::HackToggle,
|
||||
));
|
||||
}
|
||||
Some(h) => {
|
||||
children.push(sized_button(
|
||||
&format!("trigger: {}", trigger_label(h.trigger)),
|
||||
btn_palette,
|
||||
Msg::HackCycleTrigger,
|
||||
));
|
||||
match h.trigger {
|
||||
Trigger::Always => {}
|
||||
Trigger::EnergiaBajo(v) => {
|
||||
children.push(slider_view(
|
||||
"umbral",
|
||||
v,
|
||||
0.0,
|
||||
100.0,
|
||||
slider_palette,
|
||||
|phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::HackEditTriggerParam(dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
));
|
||||
}
|
||||
Trigger::EdadSobre(v) => {
|
||||
children.push(slider_view(
|
||||
"edad",
|
||||
v as f32,
|
||||
0.0,
|
||||
1000.0,
|
||||
slider_palette,
|
||||
|phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::HackEditTriggerParam(dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
));
|
||||
}
|
||||
}
|
||||
children.push(sized_button(
|
||||
&format!("acción: {} ({})", h.forced_action, action_name(h.forced_action)),
|
||||
btn_palette,
|
||||
Msg::HackCycleAction,
|
||||
));
|
||||
children.push(slider_view(
|
||||
"duración",
|
||||
h.duration as f32,
|
||||
1.0,
|
||||
500.0,
|
||||
slider_palette,
|
||||
|phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::HackEditDuration(dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
));
|
||||
children.push(sized_button("− Quitar hack", btn_palette, Msg::HackToggle));
|
||||
}
|
||||
}
|
||||
children.push(sized_button("🗑 Borrar", btn_palette, Msg::DeleteSelected));
|
||||
children.push(sized_button("◌ Deseleccionar", btn_palette, Msg::DeselectConcepto));
|
||||
}
|
||||
|
||||
/// Tab "ψ" — sliders de psicología social + métricas ψ.
|
||||
fn append_psique_tab(
|
||||
children: &mut Vec<View<Msg>>,
|
||||
model: &Model,
|
||||
stats: &WorldStats,
|
||||
psi_metrics: &PsiMetrics,
|
||||
theme: &Theme,
|
||||
btn_palette: &ButtonPalette,
|
||||
slider_palette: &SliderPalette,
|
||||
) {
|
||||
children.push(label_view("[ DIVERSIDAD ψ ]", 11.0, theme.fg_muted));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-var-psi-orden"),
|
||||
&format!("{:.3}", stats.var_psi[0]),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-var-psi-miedo"),
|
||||
&format!("{:.3}", stats.var_psi[1]),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-var-psi-curiosidad"),
|
||||
&format!("{:.3}", stats.var_psi[2]),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
&rimay_localize::t("dominium-stat-var-psi-corruptib"),
|
||||
&format!("{:.3}", stats.var_psi[3]),
|
||||
theme,
|
||||
));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ CONTAGIO SOCIAL ]", 11.0, theme.fg_muted));
|
||||
children.push(param_slider(
|
||||
"psi mod",
|
||||
model.sim.params.psi_effect_modulation,
|
||||
ParamSlot::PsiModulation,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(param_slider(
|
||||
"radio soc",
|
||||
model.sim.params.social_radius,
|
||||
ParamSlot::SocialRadius,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(param_slider(
|
||||
"contagio",
|
||||
model.sim.params.contagion_rate,
|
||||
ParamSlot::ContagionRate,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(param_slider(
|
||||
"homofilia",
|
||||
model.sim.params.homophily_threshold,
|
||||
ParamSlot::HomophilyThreshold,
|
||||
slider_palette,
|
||||
));
|
||||
let big5_label = if model.sim.params.big_five {
|
||||
"✓ Big Five: ON (5D)"
|
||||
} else {
|
||||
"○ Big Five: OFF (4D)"
|
||||
};
|
||||
children.push(sized_button(big5_label, btn_palette, Msg::ToggleBigFive));
|
||||
let policy_label = match model.sim.params.action_policy {
|
||||
dominium_core::ActionPolicy::Fixed => "○ Política: Fixed".to_string(),
|
||||
dominium_core::ActionPolicy::PsiArgmax => format!(
|
||||
"✓ Política: PsiArgmax (T={})",
|
||||
model.sim.params.policy_reeval_period
|
||||
),
|
||||
};
|
||||
children.push(sized_button(&policy_label, btn_palette, Msg::CyclePsiPolicy));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ POLARIZACIÓN Esteban-Ray ]", 11.0, theme.fg_muted));
|
||||
let psi_labels = ["ORDEN", "MIEDO", "CURIO", "CORR"];
|
||||
for (i, lab) in psi_labels.iter().enumerate() {
|
||||
children.push(stat_row(
|
||||
&format!("polar {lab}"),
|
||||
&format!("{:.4}", psi_metrics.polarization[i]),
|
||||
theme,
|
||||
));
|
||||
}
|
||||
children.push(label_view("[ Moran's I (autocorr.) ]", 11.0, theme.fg_muted));
|
||||
for (i, lab) in psi_labels.iter().enumerate() {
|
||||
children.push(stat_row(
|
||||
&format!("Moran {lab}"),
|
||||
&format!("{:+.3}", psi_metrics.moran_i[i]),
|
||||
theme,
|
||||
));
|
||||
}
|
||||
if model.sim.params.big_five {
|
||||
children.push(stat_row(
|
||||
"polar EXTRA",
|
||||
&format!("{:.4}", psi_metrics.polarization_ext),
|
||||
theme,
|
||||
));
|
||||
children.push(stat_row(
|
||||
"Moran EXTRA",
|
||||
&format!("{:+.3}", psi_metrics.moran_i_ext),
|
||||
theme,
|
||||
));
|
||||
}
|
||||
|
||||
// Legend de clusters cuando el render está mostrando tribus.
|
||||
if matches!(model.cfg.render_mode, RenderMode::PsiCluster) {
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ TRIBUS k-means ]", 11.0, theme.fg_muted));
|
||||
for (k, c) in CLUSTER_COLORS.iter().enumerate() {
|
||||
let n_in = model
|
||||
.sim
|
||||
.cluster_assignments
|
||||
.iter()
|
||||
.filter(|&&a| a as usize == k)
|
||||
.count();
|
||||
children.push(stat_row(
|
||||
&format!("cluster {k} ({})", color_swatch(*c)),
|
||||
&n_in.to_string(),
|
||||
theme,
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Tab "Vista" — render mode + trails + andina + ZWeights + rewind.
|
||||
fn append_vista_tab(
|
||||
children: &mut Vec<View<Msg>>,
|
||||
model: &Model,
|
||||
theme: &Theme,
|
||||
btn_palette: &ButtonPalette,
|
||||
slider_palette: &SliderPalette,
|
||||
) {
|
||||
children.push(label_view("[ MODO RENDER ]", 11.0, theme.fg_muted));
|
||||
let render_label = match model.cfg.render_mode {
|
||||
RenderMode::Composite => "Render: compuesto".to_string(),
|
||||
RenderMode::Heatmap(l) => format!("Render: heatmap {}", l.label()),
|
||||
RenderMode::PsiCluster => "Render: tribus ψ (k-means)".to_string(),
|
||||
};
|
||||
children.push(sized_button(&render_label, btn_palette, Msg::CycleRenderMode));
|
||||
let trails_label = if model.show_trails {
|
||||
"✓ Trayectorias: ON"
|
||||
} else {
|
||||
"○ Trayectorias: OFF"
|
||||
};
|
||||
children.push(sized_button(trails_label, btn_palette, Msg::ToggleTrails));
|
||||
let texture_label = if model.cfg.texture {
|
||||
"✓ Textura: ON"
|
||||
} else {
|
||||
"○ Textura: OFF"
|
||||
};
|
||||
children.push(sized_button(texture_label, btn_palette, Msg::ToggleTexture));
|
||||
let andina_label = if model.cfg.andina_layers > 0 {
|
||||
"✓ Estampa andina: ON"
|
||||
} else {
|
||||
"○ Estampa andina: OFF"
|
||||
};
|
||||
children.push(sized_button(andina_label, btn_palette, Msg::ToggleAndina));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ RELIEVE VISUAL ]", 11.0, theme.fg_muted));
|
||||
children.push(z_slider(
|
||||
&rimay_localize::t("dominium-slider-materia"),
|
||||
model.weights.materia,
|
||||
ZSlot::Materia,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(z_slider(
|
||||
&rimay_localize::t("dominium-slider-psique"),
|
||||
model.weights.psique,
|
||||
ZSlot::Psique,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(z_slider(
|
||||
&rimay_localize::t("dominium-slider-poder"),
|
||||
model.weights.poder,
|
||||
ZSlot::Poder,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(z_slider(
|
||||
&rimay_localize::t("dominium-slider-oro"),
|
||||
model.weights.oro,
|
||||
ZSlot::Oro,
|
||||
slider_palette,
|
||||
));
|
||||
children.push(z_slider(
|
||||
"degrad.",
|
||||
model.weights.degradacion,
|
||||
ZSlot::Degradacion,
|
||||
slider_palette,
|
||||
));
|
||||
let sync_label = if model.sync_relieve {
|
||||
"✓ Sync físico: ON"
|
||||
} else {
|
||||
"○ Sync físico: OFF"
|
||||
};
|
||||
children.push(sized_button(sync_label, btn_palette, Msg::ToggleSyncRelieve));
|
||||
|
||||
children.push(separator(theme));
|
||||
children.push(label_view("[ REWIND ]", 11.0, theme.fg_muted));
|
||||
let max_rewind = model.sim.snapshots.len().saturating_sub(1).max(1);
|
||||
children.push(slider_view(
|
||||
"rewind",
|
||||
model.sim.rewind_offset as f32,
|
||||
0.0,
|
||||
max_rewind as f32,
|
||||
slider_palette,
|
||||
|phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::RewindBy(dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
));
|
||||
if model.sim.rewind_offset > 0 {
|
||||
children.push(sized_button(
|
||||
&format!("▶ Vivo (estabas {} atrás)", model.sim.rewind_offset),
|
||||
btn_palette,
|
||||
Msg::RewindHome,
|
||||
));
|
||||
}
|
||||
}
|
||||
|
||||
/// Glifo simple para indicar el color de un cluster en una fila de stat.
|
||||
/// El texto es monoespaciado pero los colores van en el panel — usamos
|
||||
/// emojis círculos para que el matching visual sea inmediato sin tocar el
|
||||
/// renderer del label.
|
||||
fn color_swatch(c: Color) -> &'static str {
|
||||
let r = c[0] > 0.6;
|
||||
let g = c[1] > 0.6;
|
||||
let b = c[2] > 0.6;
|
||||
match (r, g, b) {
|
||||
(true, false, true) => "magenta",
|
||||
(false, true, true) => "cian",
|
||||
(true, true, false) => "amarillo",
|
||||
_ => "·",
|
||||
}
|
||||
}
|
||||
|
||||
fn label_view(text: &str, size_px: f32, color: llimphi_ui::llimphi_raster::peniko::Color) -> View<Msg> {
|
||||
View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(18.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(text.to_string(), size_px, color, Alignment::Start)
|
||||
}
|
||||
|
||||
fn stat_row(label: &str, value: &str, theme: &Theme) -> View<Msg> {
|
||||
let label_v = View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
flex_grow: 1.0,
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(label.to_string(), 12.0, theme.fg_muted, Alignment::Start);
|
||||
let value_v = View::new(Style {
|
||||
size: Size {
|
||||
width: length(90.0_f32),
|
||||
height: percent(1.0_f32),
|
||||
},
|
||||
..Default::default()
|
||||
})
|
||||
.text_aligned(value.to_string(), 12.0, theme.fg_text, Alignment::End);
|
||||
View::new(Style {
|
||||
flex_direction: FlexDirection::Row,
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(20.0_f32),
|
||||
},
|
||||
align_items: Some(AlignItems::Center),
|
||||
..Default::default()
|
||||
})
|
||||
.children(vec![label_v, value_v])
|
||||
}
|
||||
|
||||
fn sized_button(label: &str, palette: &ButtonPalette, msg: Msg) -> View<Msg> {
|
||||
let mut btn = button_view(label, palette, msg);
|
||||
btn.style.size = Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(30.0_f32),
|
||||
};
|
||||
btn
|
||||
}
|
||||
|
||||
/// Fila clicable con el nombre de un Concepto. La fila seleccionada
|
||||
/// queda resaltada con `bg_selected`; las demás reaccionan al hover.
|
||||
fn concepto_row(i: usize, id: &str, selected: bool, theme: &Theme) -> View<Msg> {
|
||||
let bg = if selected { theme.bg_selected } else { theme.bg_panel };
|
||||
View::new(Style {
|
||||
size: Size {
|
||||
width: percent(1.0_f32),
|
||||
height: length(20.0_f32),
|
||||
},
|
||||
padding: Rect {
|
||||
left: length(8.0_f32),
|
||||
right: length(6.0_f32),
|
||||
top: length(0.0_f32),
|
||||
bottom: length(0.0_f32),
|
||||
},
|
||||
align_items: Some(AlignItems::Center),
|
||||
..Default::default()
|
||||
})
|
||||
.fill(bg)
|
||||
.hover_fill(theme.bg_row_hover)
|
||||
.radius(3.0)
|
||||
.text_aligned(
|
||||
format!("· {id}"),
|
||||
12.0,
|
||||
if selected { theme.accent } else { theme.fg_text },
|
||||
Alignment::Start,
|
||||
)
|
||||
.on_click(Msg::SelectConcepto(i))
|
||||
}
|
||||
|
||||
/// Slider para una capa de `LayerMods`. Rango fijo `[-1, 1]` — encaja con
|
||||
/// el patrón típico (emisión positiva, drenaje negativo).
|
||||
fn mod_slider(label: &str, value: f32, layer: Layer, palette: &SliderPalette) -> View<Msg> {
|
||||
slider_view(
|
||||
label,
|
||||
value,
|
||||
-1.0,
|
||||
1.0,
|
||||
palette,
|
||||
move |phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::EditMod(layer, dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Slider para un slot de `SimParams`. El rango lo decide el slot.
|
||||
fn param_slider(
|
||||
label: &str,
|
||||
value: f32,
|
||||
slot: ParamSlot,
|
||||
palette: &SliderPalette,
|
||||
) -> View<Msg> {
|
||||
let (min, max) = slot.range();
|
||||
slider_view(
|
||||
label,
|
||||
value,
|
||||
min,
|
||||
max,
|
||||
palette,
|
||||
move |phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::EditParam(slot, dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
/// Slider para un slot de `ZWeights` (relieve visual del render).
|
||||
/// Rango simétrico [-2, 2]: negativo = la capa cava valles, positivo = eleva.
|
||||
fn z_slider(
|
||||
label: &str,
|
||||
value: f32,
|
||||
slot: ZSlot,
|
||||
palette: &SliderPalette,
|
||||
) -> View<Msg> {
|
||||
slider_view(
|
||||
label,
|
||||
value,
|
||||
-2.0,
|
||||
2.0,
|
||||
palette,
|
||||
move |phase, dv| match phase {
|
||||
DragPhase::Move => Some(Msg::EditZWeight(slot, dv)),
|
||||
DragPhase::End => None,
|
||||
},
|
||||
)
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
//! Generación procedural del mundo (frontend): paleta de biomas para el
|
||||
//! render y el wrapper que invoca al motor `dominium_core::worldgen` con las
|
||||
//! dimensiones, población y pack de Conceptos de esta app. El generador en sí
|
||||
//! (PRNG, fbm, ríos, biomas, lemmings) vive en el core (regla #2).
|
||||
|
||||
use dominium_core::World;
|
||||
|
||||
use crate::consts::{GRID, LEMMINGS};
|
||||
use crate::packs::{default_conceptos, load_user_pack};
|
||||
|
||||
/// Paleta retocada para que mar / tierra / cumbres se lean a primera
|
||||
/// vista. Reemplaza la `Palette::default()` del render-plan en la app sin
|
||||
/// tocar el crate (otros consumidores siguen con el default histórico).
|
||||
pub(crate) fn bioma_palette() -> dominium_render_plan::Palette {
|
||||
dominium_render_plan::Palette {
|
||||
// Arena oscura para celdas sin capa dominante — visualmente
|
||||
// "tierra de borde" en lugar del gris-azulado original.
|
||||
floor: [0.30, 0.25, 0.20, 1.0],
|
||||
// Pasto firme.
|
||||
materia: [0.30, 0.62, 0.32, 1.0],
|
||||
// Azul océano profundo (sustituye al cian claro del default).
|
||||
psique: [0.16, 0.34, 0.66, 1.0],
|
||||
// Siena de cumbre (sustituye al rojo bandera).
|
||||
poder: [0.78, 0.52, 0.32, 1.0],
|
||||
oro: [0.92, 0.76, 0.28, 1.0],
|
||||
// Gris-violeta de roca alta (sustituye al violeta saturado).
|
||||
degradacion: [0.46, 0.40, 0.50, 1.0],
|
||||
// Marfil suave para lemmings — destaca sobre pasto y agua.
|
||||
lemming: [0.97, 0.95, 0.88, 1.0],
|
||||
concepto_aura: [0.95, 0.86, 0.55, 0.18],
|
||||
concepto_base: [0.58, 0.45, 0.18, 1.0],
|
||||
concepto: [0.98, 0.88, 0.42, 1.0],
|
||||
shadow: [0.04, 0.04, 0.06, 0.42],
|
||||
}
|
||||
}
|
||||
|
||||
/// Siembra un mundo `GRID×GRID` con `LEMMINGS` lemmings. Si el usuario ya
|
||||
/// tiene un pack guardado gana sobre el embebido (así sus ediciones
|
||||
/// sobreviven al reseed/reapertura); si no, default. Delega en
|
||||
/// [`dominium_core::worldgen::seed`].
|
||||
pub(crate) fn seed(seed: u64) -> World {
|
||||
let conceptos = load_user_pack().unwrap_or_else(default_conceptos);
|
||||
dominium_core::worldgen::seed(seed, GRID, LEMMINGS, conceptos)
|
||||
}
|
||||
Reference in New Issue
Block a user