Add level 7: The Floor Map (complex nested data)

Top-level `floor:` int + `rooms:` mapping where each room carries a
type, a locked flag, an exits list, and a contents list. Two rooms
picked from a name/kind pool; exits and contents drawn from typed
pools. Deterministic per seed (ChaCha8Rng XOR'd with 0x..07).

Not wired into levels::registry() yet — integration belongs to a follow-up.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/levels/l07_complex.rs

@@ -0,0 +1,142 @@
+//! Level 7 — complex data structures. The full map of a single floor.
+//!
+//! Paired design note: `l07.md`.
+
+use rand::seq::SliceRandom;
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+use serde::Serialize;
+use serde_yaml::{Mapping, Sequence, Value};
+
+use crate::describe::Describer;
+
+use super::{Generated, Level};
+
+pub struct Complex;
+
+const EXITS: &[&str] = &["north", "south", "east", "west", "up", "down"];
+const CONTENTS: &[&str] = &[
+    "torch", "bench", "gold", "ruby", "scroll", "tome", "dagger", "shield",
+];
+const ROOMS: &[(&str, &str)] = &[
+    ("entrance", "hall"),
+    ("treasury", "vault"),
+    ("library", "study"),
+    ("kitchen", "scullery"),
+];
+
+#[derive(Serialize)]
+struct DescCtx {
+    floor: i64,
+    rooms: Vec<RoomDesc>,
+}
+
+#[derive(Serialize)]
+struct RoomDesc {
+    name: String,
+    kind: String,
+    locked: bool,
+    exits: Vec<String>,
+    contents: Vec<String>,
+}
+
+impl Level for Complex {
+    fn id(&self) -> u8 {
+        7
+    }
+
+    fn name(&self) -> &'static str {
+        "The Floor Map"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0007);
+        let floor = rng.gen_range(1..=5i64);
+        let chosen: Vec<&(&'static str, &'static str)> =
+            ROOMS.choose_multiple(&mut rng, 2).collect();
+
+        let mut rooms_map = Mapping::new();
+        let mut desc_rooms = Vec::new();
+        for (name, kind) in &chosen {
+            let exits_n = rng.gen_range(1..=3);
+            let exits: Vec<&'static str> =
+                EXITS.choose_multiple(&mut rng, exits_n).copied().collect();
+            let contents_n = rng.gen_range(1..=3);
+            let contents: Vec<&'static str> = CONTENTS
+                .choose_multiple(&mut rng, contents_n)
+                .copied()
+                .collect();
+            let locked = rng.gen_bool(0.5);
+
+            let mut room = Mapping::new();
+            room.insert(
+                Value::String("type".to_string()),
+                Value::String((*kind).to_string()),
+            );
+            room.insert(Value::String("locked".to_string()), Value::Bool(locked));
+            let exits_seq: Sequence = exits
+                .iter()
+                .map(|e| Value::String((*e).to_string()))
+                .collect();
+            let contents_seq: Sequence = contents
+                .iter()
+                .map(|c| Value::String((*c).to_string()))
+                .collect();
+            room.insert(
+                Value::String("exits".to_string()),
+                Value::Sequence(exits_seq),
+            );
+            room.insert(
+                Value::String("contents".to_string()),
+                Value::Sequence(contents_seq),
+            );
+            rooms_map.insert(Value::String((*name).to_string()), Value::Mapping(room));
+
+            desc_rooms.push(RoomDesc {
+                name: (*name).to_string(),
+                kind: (*kind).to_string(),
+                locked,
+                exits: exits.iter().map(|s| s.to_string()).collect(),
+                contents: contents.iter().map(|s| s.to_string()).collect(),
+            });
+        }
+
+        let mut top = Mapping::new();
+        top.insert(Value::String("floor".to_string()), Value::from(floor));
+        top.insert(
+            Value::String("rooms".to_string()),
+            Value::Mapping(rooms_map),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let mut d = Describer::new();
+        d.register(
+            "l07",
+            "Floor {{ floor }}.\n\
+             {% for r in rooms %}\n\
+             {{ r.name }} — a {{ r.kind }} (locked: {{ r.locked }})\n\
+             \texits:    {% for e in r.exits %}{{ e }}{% if not loop.last %}, {% endif %}{% endfor %}\n\
+             \tcontents: {% for c in r.contents %}{{ c }}{% if not loop.last %}, {% endif %}{% endfor %}\n\
+             {% endfor %}\n\
+             💡 Combine maps, lists, and scalars — `floor:` is an int, each room is a dict with two lists.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l07",
+                &DescCtx {
+                    floor,
+                    rooms: desc_rooms,
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "🗺 The map of this floor is rich with detail.".to_string(),
+        }
+    }
+}

src/levels/l09_operators.rs

@@ -1,135 +0,0 @@
-//! Level 9 — special operators. The merge key (`<<`) lets a door
-//! inherit a template and override one field.
-//!
-//! Paired design note: `l09.md`.
-//!
-//! `serde_yaml` treats `<<` as a literal mapping key (it does NOT
-//! perform YAML 1.1 merge-key resolution). The target therefore carries
-//! a `<<` key whose value is the defaults dict, exactly as the player's
-//! `<<: *defaults` parses.
-
-use rand::seq::SliceRandom;
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha8Rng;
-use serde::Serialize;
-use serde_yaml::{Mapping, Value};
-
-use crate::describe::Describer;
-
-use super::{Generated, Level};
-
-pub struct Operators;
-
-const MATERIALS: &[&str] = &["oak", "iron", "stone", "silver", "bone"];
-
-#[derive(Serialize)]
-struct DescCtx {
-    default_material: String,
-    default_locked: bool,
-    north_locked: bool,
-    south_material: String,
-}
-
-impl Level for Operators {
-    fn id(&self) -> u8 {
-        9
-    }
-
-    fn name(&self) -> &'static str {
-        "Merge Keys"
-    }
-
-    fn generate(&self, seed: u64) -> Generated {
-        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0009);
-        let default_material = (*MATERIALS.choose(&mut rng).unwrap()).to_string();
-        let default_locked = rng.gen_bool(0.5);
-        // The north door overrides locked; choose the opposite so the
-        // override is meaningful.
-        let north_locked = !default_locked;
-        // The south door overrides material; pick anything but default.
-        let other_materials: Vec<&str> = MATERIALS
-            .iter()
-            .filter(|m| **m != default_material)
-            .copied()
-            .collect();
-        let south_material = (*other_materials.choose(&mut rng).unwrap()).to_string();
-
-        // Build the defaults mapping (referenced by all doors).
-        let mut defaults = Mapping::new();
-        defaults.insert(
-            Value::String("material".to_string()),
-            Value::String(default_material.clone()),
-        );
-        defaults.insert(
-            Value::String("locked".to_string()),
-            Value::Bool(default_locked),
-        );
-
-        let mut north_door = Mapping::new();
-        north_door.insert(
-            Value::String("<<".to_string()),
-            Value::Mapping(defaults.clone()),
-        );
-        north_door.insert(
-            Value::String("locked".to_string()),
-            Value::Bool(north_locked),
-        );
-
-        let mut south_door = Mapping::new();
-        south_door.insert(
-            Value::String("<<".to_string()),
-            Value::Mapping(defaults.clone()),
-        );
-        south_door.insert(
-            Value::String("material".to_string()),
-            Value::String(south_material.clone()),
-        );
-
-        let mut top = Mapping::new();
-        top.insert(
-            Value::String("door_defaults".to_string()),
-            Value::Mapping(defaults),
-        );
-        top.insert(
-            Value::String("north_door".to_string()),
-            Value::Mapping(north_door),
-        );
-        top.insert(
-            Value::String("south_door".to_string()),
-            Value::Mapping(south_door),
-        );
-
-        let target_yaml =
-            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
-
-        let mut d = Describer::new();
-        d.register(
-            "l09",
-            "Two doors share a template:\n\
-             default material: {{ default_material }}\n\
-             default locked:   {{ default_locked }}\n\
-             \n\
-             north_door overrides locked → {{ north_locked }}\n\
-             south_door overrides material → {{ south_material }}\n\
-             💡 Anchor the defaults (`door_defaults: &name`) and merge with `<<: *name` in each door.",
-        )
-        .expect("register template");
-        let description = d
-            .render(
-                "l09",
-                &DescCtx {
-                    default_material,
-                    default_locked,
-                    north_locked,
-                    south_material,
-                },
-            )
-            .expect("render template");
-
-        Generated {
-            target_yaml,
-            description,
-            flavor: "🚪 Two doors echo a single template.".to_string(),
-        }
-    }
-}

src/levels/mod.rs

@@ -13,7 +13,7 @@
 pub mod l01_minimum;
 pub mod l02_kv;
 pub mod l03_dict;
-pub mod l09_operators;
+pub mod l07_complex;
 
 use serde::{Deserialize, Serialize};