feat(jogo): expediente dos mortos, jogo de zumbis em primeira pessoa

Etapa 1 inteira (logica com 100% de cobertura, cena 3D, toque, sons, bancada de desempenho, e2e) e a base da etapa 2 (mapa novo no Tiled, texturas, imagens dos itens, sons conferidos, golpe recortado e medido). Pagina /jogo fora do menu e do sitemap ate a medicao no celular.

lib/jogo/hordas.test.ts

@@ -0,0 +1,113 @@
+import { escolherHordas, montarFila, tamanhoDaHorda } from "./hordas";
+import { problemaPorId, problemasDaArea } from "./problemas";
+import { sortearInteiro } from "./rng";
+import type { Dificuldade } from "./tipos";
+
+describe("tamanhoDaHorda", () => {
+  it.each([
+    [0, "facil", 8],
+    [1, "facil", 11],
+    [2, "facil", 14],
+    [0, "normal", 12],
+    [1, "normal", 16],
+    [2, "normal", 20],
+    [0, "dificil", 16],
+    [1, "dificil", 21],
+    [2, "dificil", 26],
+  ] as const)("horda %i no %s tem %i", (indice, dificuldade, esperado) => {
+    expect(tamanhoDaHorda(indice, dificuldade)).toBe(esperado);
+  });
+
+  it("lança erro para índice fora de 0 a 2", () => {
+    expect(() => tamanhoDaHorda(3, "normal")).toThrow(Error);
+    expect(() => tamanhoDaHorda(-1, "normal")).toThrow(Error);
+  });
+});
+
+describe("escolherHordas", () => {
+  const id = "site-lento";
+  const area = problemaPorId(id)?.area ?? "vender";
+
+  it("devolve 3 outros problemas da área, sem repetir, e o próprio id por último", () => {
+    for (let rng = 1; rng <= 30; rng++) {
+      const ids = escolherHordas({ rng }, id);
+      expect(ids).toHaveLength(4);
+      expect(ids[3]).toBe(id);
+      expect(new Set(ids).size).toBe(4);
+      for (const outro of ids) {
+        expect(problemaPorId(outro)?.area).toBe(area);
+      }
+    }
+  });
+
+  it("usa sortearInteiro sobre os candidatos restantes", () => {
+    const p = { rng: 7 };
+    const copia = { rng: 7 };
+    const outros = problemasDaArea(area)
+      .map((problema) => problema.id)
+      .filter((outro) => outro !== id);
+    const esperado: string[] = [];
+    for (let i = 0; i < 3; i++) {
+      const [escolhido] = outros.splice(
+        sortearInteiro(copia, outros.length),
+        1,
+      );
+      esperado.push(escolhido);
+    }
+    expect(escolherHordas(p, id)).toEqual([...esperado, id]);
+  });
+
+  it("lança erro para id inexistente", () => {
+    expect(() => escolherHordas({ rng: 1 }, "nao-existe")).toThrow(Error);
+  });
+});
+
+describe("montarFila", () => {
+  const tipos = (indice: number, dificuldade: Dificuldade = "normal") =>
+    montarFila(indice, "x", dificuldade).map((n) => n.tipo);
+
+  it("horda 0: todos comuns", () => {
+    expect(tipos(0)).toEqual(Array(12).fill("comum"));
+  });
+
+  it("horda 1: alterna comum e rápido", () => {
+    const t = tipos(1);
+    expect(t).toHaveLength(16);
+    expect(t.slice(0, 4)).toEqual(["comum", "rapido", "comum", "rapido"]);
+    expect(t.filter((x) => x === "comum")).toHaveLength(8);
+    expect(t.filter((x) => x === "rapido")).toHaveLength(8);
+  });
+
+  it("horda 2: posição módulo 5", () => {
+    const t = tipos(2);
+    expect(t).toHaveLength(20);
+    expect(t.slice(0, 5)).toEqual([
+      "comum",
+      "comum",
+      "rapido",
+      "rapido",
+      "blindado",
+    ]);
+    expect(t.slice(15)).toEqual(t.slice(0, 5));
+  });
+
+  it("chefão: um chefão e a escolta fixa, sem mudar com a dificuldade", () => {
+    const esperado = ["chefao", ...Array(6).fill("comum")];
+    expect(tipos(3)).toEqual(esperado);
+    expect(tipos(3, "dificil")).toEqual(esperado);
+  });
+
+  it("o tamanho segue a dificuldade e todos levam o problemaId", () => {
+    const fila = montarFila(0, "abc", "facil");
+    expect(fila).toHaveLength(8);
+    expect(fila.every((n) => n.problemaId === "abc")).toBe(true);
+    expect(
+      montarFila(3, "abc", "facil").every((n) => n.problemaId === "abc"),
+    ).toBe(true);
+  });
+
+  it("lança erro para índice fora de 0 a 3", () => {
+    expect(() => montarFila(4, "x", "normal")).toThrow(Error);
+    expect(() => montarFila(-1, "x", "normal")).toThrow(Error);
+  });
+});