Add level 11: Advanced Anchors

`shapes:` list defines 2-3 polygons (name + sides + interior angle sum);
`copies:` is a list of 3-4 selections (with possible repetition) drawn
from the same pool. serde_yaml expands aliases on parse, so the target
is the inlined form; players using `- &name` anchors inside the list
and `*name` aliases in `copies:` produce the same Value and pass via
the semantic short-circuit.

All randomised per seed (ChaCha8Rng XOR'd with 0x..0B).

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/l08_tags.rs

@@ -1,111 +0,0 @@
-//! Level 8 — tags and newlines. The scroll preserves its lines and
-//! demands explicit types.
-//!
-//! Paired design note: `l08.md`.
-//!
-//! The target value uses:
-//! - a multi-line string for `scroll:` (block scalar `|` round-trips through
-//!   serde_yaml as a `Value::String` with embedded newlines),
-//! - a fractional float for `weight:` (forces float type without needing the
-//!   `!!float` tag in the target text — but the player can use either),
-//! - a string of digits for `title:` (player needs quotes or `!!str` to
-//!   avoid the integer interpretation).
-
-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 Tags;
-
-const VERBS: &[&str] = &["Beware", "Avoid", "Heed", "Mark"];
-const NOUNS: &[&str] = &[
-    "the path that turns twice",
-    "the third spring",
-    "the silent statue",
-    "the moonlit door",
-];
-const TITLES: &[&str] = &["1024", "2048", "4096", "8192"];
-
-#[derive(Serialize)]
-struct DescCtx {
-    scroll_lines: Vec<String>,
-    weight: f64,
-    title: String,
-}
-
-impl Level for Tags {
-    fn id(&self) -> u8 {
-        8
-    }
-
-    fn name(&self) -> &'static str {
-        "Scroll of Tags"
-    }
-
-    fn generate(&self, seed: u64) -> Generated {
-        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_0008);
-
-        let line_n = 2;
-        let scroll_lines: Vec<String> = (0..line_n)
-            .map(|_| {
-                let v = VERBS.choose(&mut rng).unwrap();
-                let n = NOUNS.choose(&mut rng).unwrap();
-                format!("{v} {n}.")
-            })
-            .collect();
-        // Block scalar `|` produces a string ending in `\n` after the last line.
-        let scroll_text = format!("{}\n", scroll_lines.join("\n"));
-
-        // Fractional weight so serde_yaml's float serialisation keeps the
-        // `.5` and matches the player's submission unambiguously.
-        let weight = rng.gen_range(1..=20) as f64 + 0.5;
-        let title = TITLES.choose(&mut rng).unwrap().to_string();
-
-        let mut top = Mapping::new();
-        top.insert(
-            Value::String("scroll".to_string()),
-            Value::String(scroll_text),
-        );
-        top.insert(Value::String("weight".to_string()), Value::from(weight));
-        top.insert(
-            Value::String("title".to_string()),
-            Value::String(title.clone()),
-        );
-
-        let target_yaml =
-            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
-
-        let mut d = Describer::new();
-        d.register(
-            "l08",
-            "A scroll demands its types. Match exactly:\n\
-             scroll: multi-line text{% for line in scroll_lines %}\n  {{ line }}{% endfor %}\n\
-             weight: must parse as the float {{ weight }}\n\
-             title:  must parse as the string \"{{ title }}\"\n\
-             💡 Block scalar `|` preserves newlines; `!!str` (or quotes) forces a digit-only string.",
-        )
-        .expect("register template");
-        let description = d
-            .render(
-                "l08",
-                &DescCtx {
-                    scroll_lines,
-                    weight,
-                    title,
-                },
-            )
-            .expect("render template");
-
-        Generated {
-            target_yaml,
-            description,
-            flavor: "📜 An ancient scroll insists on its precise form.".to_string(),
-        }
-    }
-}

src/levels/l11_adv_anchors.rs

@@ -0,0 +1,141 @@
+//! Level 11 — advanced anchors. Anchor shapes inside a list, alias
+//! them elsewhere.
+//!
+//! Paired design note: `l11.md`.
+//!
+//! Like L6, serde_yaml expands aliases on parse, so the emitted target
+//! is the fully-inlined form. Players who use `&anchor` / `*alias`
+//! produce the same `Value` and pass via the semantic short-circuit.
+
+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 AdvAnchors;
+
+const SHAPES: &[(&str, i64)] = &[
+    ("triangle", 3),
+    ("square", 4),
+    ("pentagon", 5),
+    ("hexagon", 6),
+    ("heptagon", 7),
+    ("octagon", 8),
+];
+
+#[derive(Serialize)]
+struct DescCtx {
+    shapes: Vec<ShapeDesc>,
+    copies: Vec<String>,
+}
+
+#[derive(Serialize)]
+struct ShapeDesc {
+    name: String,
+    sides: i64,
+    interior_angle_sum: i64,
+}
+
+fn shape_value(name: &str, sides: i64) -> Value {
+    let mut m = Mapping::new();
+    m.insert(
+        Value::String("name".to_string()),
+        Value::String(name.to_string()),
+    );
+    m.insert(Value::String("sides".to_string()), Value::from(sides));
+    m.insert(
+        Value::String("interior".to_string()),
+        Value::from((sides - 2) * 180),
+    );
+    Value::Mapping(m)
+}
+
+impl Level for AdvAnchors {
+    fn id(&self) -> u8 {
+        11
+    }
+
+    fn name(&self) -> &'static str {
+        "Advanced Anchors"
+    }
+
+    fn generate(&self, seed: u64) -> Generated {
+        let mut rng = ChaCha8Rng::seed_from_u64(seed ^ 0x0000_0000_0000_000B);
+
+        let n = rng.gen_range(2..=3);
+        let picked: Vec<(&'static str, i64)> = SHAPES
+            .choose_multiple(&mut rng, n)
+            .copied()
+            .collect();
+
+        // The defining `shapes:` list.
+        let shapes_seq: Sequence = picked
+            .iter()
+            .map(|(name, sides)| shape_value(name, *sides))
+            .collect();
+
+        // `copies:` — random selections with possible repetition.
+        let m = rng.gen_range(3..=4);
+        let mut copies_seq = Sequence::new();
+        let mut copy_names = Vec::new();
+        for _ in 0..m {
+            let (name, sides) = picked.choose(&mut rng).unwrap();
+            copies_seq.push(shape_value(name, *sides));
+            copy_names.push((*name).to_string());
+        }
+
+        let mut top = Mapping::new();
+        top.insert(
+            Value::String("shapes".to_string()),
+            Value::Sequence(shapes_seq),
+        );
+        top.insert(
+            Value::String("copies".to_string()),
+            Value::Sequence(copies_seq),
+        );
+
+        let target_yaml =
+            serde_yaml::to_string(&Value::Mapping(top)).expect("serialise mapping");
+
+        let shape_descs: Vec<ShapeDesc> = picked
+            .iter()
+            .map(|(name, sides)| ShapeDesc {
+                name: (*name).to_string(),
+                sides: *sides,
+                interior_angle_sum: (sides - 2) * 180,
+            })
+            .collect();
+
+        let mut d = Describer::new();
+        d.register(
+            "l11",
+            "Shapes are defined once and reused.\n\
+             Definitions:\n\
+             {% for s in shapes %}- {{ s.name }}: sides={{ s.sides }}, interior={{ s.interior_angle_sum }}\n\
+             {% endfor %}\n\
+             Copies, in order: {% for c in copies %}{{ c }}{% if not loop.last %}, {% endif %}{% endfor %}\n\
+             💡 Anchor each shape in the list with `- &name`, then alias by `*name` in copies.",
+        )
+        .expect("register template");
+        let description = d
+            .render(
+                "l11",
+                &DescCtx {
+                    shapes: shape_descs,
+                    copies: copy_names,
+                },
+            )
+            .expect("render template");
+
+        Generated {
+            target_yaml,
+            description,
+            flavor: "🔺 The geometry chamber repeats its forms.".to_string(),
+        }
+    }
+}

src/levels/mod.rs

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