// Lugares montados por PEÇAS (não há cenário pronto): paleta + céu/hora + chão + peças posicionadas por // profundidade (z: 0 = frente, 1 = fundo). Parque de dia, cemitério na névoa, quarto à noite, bunker com foco // de luz… tudo sai da mesma gramática. Espaço de desenho 1080×1920; chão começa em `horizon` (fração da altura). // // Regras de acabamento (valem para toda peça, ver elements/paint.ts): sombreado em 2 tons com a luz vindo da // esquerda; 3 planos com perspectiva atmosférica (o fundo puxa para a cor do céu/parede, a frente escurece); // sombra de contato no chão sob cada objeto. Tudo por mistura de cor — nada de blur por quadro. import React from "react"; import { rng } from "./random"; import type { ShotSpec } from "./spec"; import { makePaint, mix, palette, type Pal, type PaletteId } from "./elements/paint"; import { NATURE, type Draw } from "./elements/nature"; import { BUILT, FRONT_PART } from "./elements/built"; import { INDOOR } from "./elements/indoor"; export { PALETTES, palette, type PaletteId } from "./elements/paint"; export const GROUNDS = ["grass", "street", "dirt", "floor", "sand", "water", "none"] as const; export const ELEMENTS = ["tree", "deadtree", "pine", "bush", "rock", "mountain", "cloud", "bench", "lamp", "gravestone", "cross", "fence", "house", "building", "car", "sign", "door", "window", "table", "bed", "shelf", "crate", "tent", "fire", "ark", "ark_frame", "scaffold", "planks", "rainbow", "waves", "palm", "outcrop", "cabinet", "locker", "frame", "pendant", "desklamp", "desk", "clothesline", "wall", "facade", "shopfront"] as const; /** Tempo por cima da cena (chuva caindo; tempestade = chuva forte + relâmpago + céu mais escuro). */ export const WEATHERS = ["none", "rain", "storm"] as const; export type ElementKind = (typeof ELEMENTS)[number]; /** Fonte de luz posicionada (`spec.lightSource`): luminária, janela ou sol. */ export const LIGHT_SOURCES = ["lamp", "window", "sun"] as const; export type Place = { ground: (typeof GROUNDS)[number]; /** Interno: parede no lugar do céu (quarto, bunker, loja). */ indoor?: boolean; /** Linha do horizonte / pé da parede (fração da altura; padrão 0,56 fora e 0,62 dentro). */ horizon?: number; fog?: boolean; weather?: (typeof WEATHERS)[number]; /** Água cobrindo o lugar: altura da superfície (fração da altura do quadro, 0 = topo) do início ao fim do trecho. * Ex.: { from: 0.8, to: 0.5 } = a água sobe. O que não boia fica embaixo dela. */ flood?: { from: number; to: number }; elements: { kind: ElementKind; x: number; z?: number; scale?: number; flip?: boolean; color?: string; /** Sobe a peça (fração da altura do quadro): arca em cima do monte. */ lift?: number; /** Boia na água (com `flood`, acompanha a superfície e balança). */ float?: boolean; /** Tem gente DENTRO (arca, carro): a parte da frente da peça é desenhada por cima dos personagens. */ occupied?: boolean; }[]; }; const W = 1080; const H = 1920; const DRAW: Record = { ...NATURE, ...BUILT, ...INDOOR }; /** Peças presas na parede do fundo quando o lugar é interno (o z delas é ignorado). */ const WALL_MOUNTED = new Set(["window", "frame", "door"]); /** Peças penduradas no teto: a origem é o topo do quadro. */ const CEILING = new Set(["pendant"]); /** Objetos de mesa: sobem sozinhos para cima da mesa/escrivaninha mais próxima (se não tiver `lift`). */ const ON_TOP = new Set(["desklamp"]); /** Altura do tampo (unidades da peça) das superfícies que recebem objetos de mesa. */ const SURFACE_TOP: Partial> = { desk: 330, table: 304 }; /** Só as peças assimétricas espelham; nas simétricas o `flip` trocaria só o lado da sombra (a luz é sempre da esquerda). */ const FLIPPABLE = new Set(["deadtree", "palm", "car", "bed", "desklamp", "waves", "clothesline", "outcrop"]); /** Meia largura da base de cada peça (unidades da peça) para a sombra de contato; 0 = sem sombra. */ const FOOT: Partial> = { tree: 130, deadtree: 90, pine: 190, bush: 220, rock: 130, bench: 270, lamp: 60, gravestone: 125, cross: 60, fence: 470, house: 420, building: 280, car: 390, sign: 40, table: 290, bed: 400, shelf: 230, crate: 170, tent: 350, fire: 130, ark: 380, ark_frame: 380, scaffold: 140, planks: 185, palm: 80, outcrop: 340, cabinet: 185, locker: 330, desk: 340, wall: 730, facade: 560, shopfront: 460, desklamp: 90, clothesline: 0, }; const isNight = (id: PaletteId | undefined) => (id ?? "night") === "night"; /** Zoom do fundo pelo enquadramento: em meio corpo/de perto a câmera está mais perto, o fundo cresce junto. */ function backgroundZoom(spec: ShotSpec): number { const framings = (spec.actors ?? []).flatMap((a) => (a.kind === "person" && a.framing ? [a.framing] : [])); if (framings.includes("close")) return 1.32; if (framings.includes("medium")) return 1.16; return 1; } type El = Place["elements"][number] & { i: number; z: number }; type Placed = { e: El; x: number; y: number; s: number; zEff: number; flip: boolean }; type Layout = { horizon: number; indoor: boolean; zoom: number; items: Placed[] }; /** Onde cada peça fica (base, escala, profundidade efetiva). A camada de luz usa a mesma conta. */ export function layoutPlace(spec: ShotSpec): Layout { const place = spec.place!; const indoor = !!place.indoor; const horizon = (place.horizon ?? (indoor ? 0.62 : 0.56)) * H; const near = indoor ? H * 0.8 : H * 0.72; const items: Placed[] = place.elements.map((raw, i) => { const e: El = { ...raw, i, z: raw.z ?? 0.3 }; const wall = indoor && WALL_MOUNTED.has(e.kind); const zEff = wall ? 1 : e.z; const depth = 1 - zEff * (indoor ? 0.35 : 0.62); const s = (e.scale ?? 1) * depth * 1.15; let y: number; if (CEILING.has(e.kind)) y = 0; else if (e.kind === "cloud") y = horizon * (0.15 + 0.5 * e.z); else y = horizon + (1 - zEff) * (near - horizon); y -= (e.lift ?? 0) * H; return { e, x: e.x * W, y, s, zEff, flip: !!e.flip && FLIPPABLE.has(e.kind) }; }); // Objeto de mesa perto de uma mesa (mesma profundidade, dentro do tampo) vai para cima dela. for (const it of items) { if (!ON_TOP.has(it.e.kind) || it.e.lift !== undefined) continue; const surface = items.find((o) => SURFACE_TOP[o.e.kind] && Math.abs(o.e.z - it.e.z) <= 0.25 && Math.abs(o.x - it.x) < (FOOT[o.e.kind] ?? 0) * o.s); if (!surface) continue; it.y = surface.y - SURFACE_TOP[surface.e.kind]! * surface.s; it.s = surface.s * (it.e.scale ?? 1) * 0.9; it.zEff = surface.zEff - 0.001; } items.sort((a, b) => b.zEff - a.zEff || a.e.i - b.e.i); return { horizon, indoor, zoom: backgroundZoom(spec), items }; } /** Sol/lua no céu (sempre do lado esquerdo: é de lá que vem a luz das peças). */ export function sunOf(id: PaletteId | undefined, horizon: number): { x: number; y: number; r: number } | null { switch (id ?? "night") { case "day": return { x: W * 0.2, y: H * 0.2, r: 66 }; case "sepia": return { x: W * 0.2, y: H * 0.19, r: 70 }; case "dusk": return { x: W * 0.2, y: horizon - H * 0.13, r: 96 }; case "night": return { x: W * 0.22, y: H * 0.15, r: 44 }; default: return null; } } /** Altura da superfície da água no instante (fração da altura; null = sem enchente). */ export function floodLevel(place: Place | undefined, progress: number): number | null { if (!place?.flood) return null; const p = Math.max(0, Math.min(1, progress)); const k = p < 0.5 ? 2 * p * p : 1 - (-2 * p + 2) ** 2 / 2; return place.flood.from + (place.flood.to - place.flood.from) * k; } /** Uma peça no lugar: sombra de contato + desenho com a tinta da profundidade dela. */ function PlacedElement({ it, pal, spec, hazeColor, y, rot = 0, part }: { it: Placed; pal: Pal; spec: ShotSpec; hazeColor: string; y?: number; rot?: number; part?: "front" }) { const { e } = it; const place = spec.place!; const indoor = !!place.indoor; const z = it.zEff; const sky = e.kind === "cloud" || e.kind === "rainbow"; const haze = sky ? 0.12 : indoor ? z * 0.22 : Math.min(0.85, Math.pow(z, 1.8) * 0.66 + (place.fog ? 0.04 + z * 0.16 : 0)); const front = !sky && z < 0.25 ? (0.25 - z) * 0.5 : 0; const p = makePaint(pal, rng(spec.seed + e.i * 17), { haze, hazeColor, front, indoor, night: isNight(spec.palette) }); const draw = part === "front" ? FRONT_PART[e.kind] : DRAW[e.kind]; if (!draw) return null; const foot = (CEILING.has(e.kind) || (indoor && WALL_MOUNTED.has(e.kind)) || e.float || (e.lift ?? 0) > 0.02) ? 0 : FOOT[e.kind] ?? 0; const s = it.s; return ( {foot > 0 && part !== "front" && } {draw(p, e.color)} ); } /** Céu com degradê rico, sol/lua com halo (ou parede do interior). Não muda com o quadro. */ function SkyLayer({ spec, horizon }: { spec: ShotSpec; horizon: number }) { const pal = palette(spec.palette); const place = spec.place!; if (place.indoor) { const wallTop = mix(pal.wall, pal.ink, 0.42); return ; } const sun = sunOf(spec.palette, horizon); const night = isNight(spec.palette); return {sun && } {sun && <> {night ? <> : } } ; } /** Chão (degradê + textura) e, ao fundo, a silhueta distante (morros ou cidade). */ function GroundLayer({ spec, horizon, hazeColor }: { spec: ShotSpec; horizon: number; hazeColor: string }) { const place = spec.place!; const pal = palette(spec.palette); const rand = rng(spec.seed + 29); const out: React.ReactNode[] = []; const g = place.ground === "none" ? null : pal.ground[place.ground]; const span = H - horizon; if (place.indoor) { // Parede: lambri (meia-parede) ou listras, conforme a semente; rodapé no pé da parede. const wall = pal.wall; if (spec.seed % 2 === 0) { const top = horizon - H * 0.17; out.push(); out.push( `M${i * 150 + 40} ${top + 30} L${i * 150 + 40} ${horizon - 40} L${i * 150 + 150} ${horizon - 40}`).join(" ")} stroke={mix(wall, pal.ink, 0.3)} strokeWidth={6} fill="none" />); out.push(); out.push(); } else { out.push( `M${i * 96 + 30} 0 L${i * 96 + 30} ${horizon}`).join(" ")} stroke={mix(wall, pal.ink, 0.1)} strokeWidth={26} />); } out.push(); } else if (place.ground === "grass" || place.ground === "dirt" || place.ground === "sand") { // Morros distantes em 2 camadas, bem apagados (plano de fundo). const ridge = (h: number, amp: number, seed: number) => { const r = rng(seed); let d = `M0 ${horizon + 2} L0 ${horizon - h}`; for (let x = 0; x <= W + 180; x += 180) d += ` Q${x + 90} ${horizon - h - amp * (0.4 + r())} ${x + 180} ${horizon - h + (r() - 0.5) * amp * 0.5}`; return d + ` L${W} ${horizon + 2} Z`; }; out.push(); out.push(); } else if (place.ground === "street") { // Cidade ao longe: blocos apagados com algumas janelas. let x = -20; const blocks: React.ReactNode[] = []; while (x < W) { const w = 90 + rand() * 120; const h = H * (0.05 + rand() * 0.09); blocks.push(); x += w - 6; } out.push({blocks}); } if (g) { out.push(); if (place.ground === "floor") { // Tábuas em perspectiva: linhas que fogem para o ponto de fuga, juntas desencontradas, tom alternado. const vpY = horizon - H * 0.3; const k = (H - vpY) / (horizon - vpY); const at = (xh: number, y: number) => W / 2 + (xh - W / 2) * ((y - vpY) / (horizon - vpY)); const n = 16; const step = W / 9; let seams = ""; for (let i = -n; i <= n; i++) { const xh = W / 2 + i * step * 0.5; if (Math.abs(i) % 2 === 1) { const x2 = W / 2 + (i + 1) * step * 0.5; out.push(); } seams += `M${xh} ${horizon} L${W / 2 + (xh - W / 2) * k} ${H} `; for (let j = 0; j < 3; j++) { const y = horizon + span * Math.pow(rand(), 1.4); const xa = at(xh, y); const xb = at(xh + step * 0.5, y); seams += `M${xa} ${y} L${xb} ${y} `; } } out.push(); out.push(); out.push(); out.push(); } else if (place.ground === "street") { const walk = horizon + span * 0.16; const walkC = mix(mix("#d2c8b4", g, 0.3), hazeColor, 0.15); out.push(); out.push( { const x = -120 + i * 110; return `M${x} ${horizon} L${W / 2 + (x - W / 2) * 1.25} ${walk}`; }).join(" ") + ` M0 ${(horizon + walk) / 2} L${W} ${(horizon + walk) / 2}`} stroke={mix(walkC, pal.ink, 0.18)} strokeWidth={3} fill="none" />); out.push(); out.push(); const lane = walk + (H - walk) * 0.42; out.push( `M${i * 190 - 60} ${lane} l120 0`).join(" ")} stroke="#f2ecd8" strokeWidth={12} opacity={0.55} />); } else if (place.ground === "grass" || place.ground === "dirt" || place.ground === "sand") { // Faixas na perspectiva + tufos/pedrinhas/ondulações, maiores perto da câmera. for (let b = 1; b < 6; b++) { const y0 = horizon + span * Math.pow(b / 6, 1.7); const y1 = horizon + span * Math.pow((b + 0.45) / 6, 1.7); out.push(); } let marks = ""; for (let i = 0; i < 46; i++) { const t = Math.pow(rand(), 0.8); const y = horizon + span * t; const x = rand() * W; const s = 6 + t * 26; if (place.ground === "grass") marks += `M${x - s} ${y} L${x - s * 0.3} ${y - s * 1.4} L${x} ${y} L${x + s * 0.4} ${y - s * 1.6} L${x + s} ${y} `; else if (place.ground === "sand") marks += `M${x - s * 3} ${y} Q${x} ${y - s * 0.6} ${x + s * 3} ${y} `; else marks += `M${x - s * 0.6} ${y} a${s * 0.6} ${s * 0.28} 0 1 0 ${s * 1.2} 0 a${s * 0.6} ${s * 0.28} 0 1 0 ${-s * 1.2} 0 `; } out.push(); } } return {out}; } export function PlaceBackground({ spec, frame, progress = 0 }: { spec: ShotSpec; frame: number; progress?: number }) { const place = spec.place!; const pal = palette(spec.palette); const layout = React.useMemo(() => layoutPlace(spec), [spec]); const { horizon, zoom } = layout; const hazeColor = place.indoor ? pal.wall : mix(mix(pal.sky[2], pal.sky[1], 0.25), "#c8ccd6", place.fog ? 0.45 : 0); const level = floodLevel(place, progress); const waterY = level === null ? null : level * H; const storm = place.weather === "storm"; const ground = place.ground === "none" ? null : pal.ground[place.ground]; // Tudo que não muda com o quadro é desenhado uma vez só (céu, chão, peças paradas). const sky = React.useMemo(() => , [spec, horizon]); const floating = (it: Placed) => !!it.e.float && waterY !== null; const staticBack = React.useMemo(() => ( {layout.items.filter((it) => !(it.e.float && place.flood)).map((it) => )} ), [spec, layout]); // eslint-disable-line react-hooks/exhaustive-deps const rand = rng(spec.seed + 13); const stars = !place.indoor && isNight(spec.palette) ? Array.from({ length: 60 }, () => ({ x: rand() * W, y: rand() * horizon * 0.8, r: 1 + rand() * 2, p: rand() * 6 })) : []; const zoomT = zoom === 1 ? undefined : `translate(${W / 2} ${horizon}) scale(${zoom}) translate(${-W / 2} ${-horizon})`; return ( {ground && {place.indoor ? <> : <>} } {sky} {stars.map((s, i) => )} {staticBack} {waterY !== null && ( `Q${i * 108 + 54} ${waterY - 22 + Math.sin(frame / 9 + i) * 8} ${(i + 1) * 108} ${waterY}`).join(" ")}`} stroke="#ffffff" strokeWidth={7} fill="none" opacity={0.55} /> )} {place.ground === "water" && waterY === null && Array.from({ length: 6 }, (_, i) => ( ))} {layout.items.filter(floating).map((it) => ( // Boia: a quilha fica um pouco abaixo da superfície e a peça balança com a água. ))} {waterY !== null && } {place.fog && } ); } type LightSpot = { kind: "lamp" | "window" | "sun" | "glow"; x: number; y: number; w?: number; h?: number; spread?: number; fixture?: boolean }; /** Fonte de luz do trecho: a escolhida no spec, ou deduzida das peças (luminária > janela > sol). */ export function resolveLight(spec: ShotSpec | undefined, light: ShotSpec["light"]): LightSpot | null { if (light === "none") return null; const src = spec?.lightSource; if (src) { const dy = src.kind === "lamp" ? 0.2 : src.kind === "window" ? 0.32 : 0.2; return { kind: src.kind, x: src.x * W, y: (src.y ?? dy) * H, w: W * 0.3, h: H * 0.18 }; } const place = spec?.scene.kind === "place" ? spec.place : undefined; const layout = place ? layoutPlace(spec!) : null; const toScreen = (x: number, y: number) => layout && layout.zoom !== 1 ? { x: W / 2 + (x - W / 2) * layout.zoom, y: layout.horizon + (y - layout.horizon) * layout.zoom } : { x, y }; const pendant = layout?.items.find((it) => it.e.kind === "pendant"); if (pendant && (light === "spot" || light === undefined)) { const z = layout!.zoom; const b = toScreen(pendant.x, pendant.y + 376 * pendant.s); return { kind: "lamp", x: b.x, y: b.y, spread: 130 * pendant.s * z }; } // Luminária de mesa acesa: brilho quente em volta da cúpula, o resto do lugar no escuro. const desk = layout?.items.find((it) => it.e.kind === "desklamp"); if (desk && light === undefined) { const k = desk.flip ? -1 : 1; const a = toScreen(desk.x + k * 40 * desk.s, desk.y - 130 * desk.s); return { kind: "glow", x: a.x, y: a.y, spread: 420 * desk.s * layout!.zoom }; } if (light === "spot") return { kind: "lamp", x: W / 2, y: H * 0.045, spread: W * 0.07, fixture: true }; if (light !== undefined || !place || !layout) return null; if (place.indoor) { const win = layout.items.find((it) => it.e.kind === "window"); if (!win) return null; const a = toScreen(win.x - 186 * win.s, win.y - 616 * win.s); const b = toScreen(win.x + 186 * win.s, win.y - 244 * win.s); return { kind: "window", x: (a.x + b.x) / 2, y: (a.y + b.y) / 2, w: b.x - a.x, h: b.y - a.y }; } const sun = sunOf(spec!.palette, layout.horizon); if (!sun || isNight(spec!.palette)) return null; return { kind: "sun", x: sun.x, y: sun.y }; } /** * Luz por cima de tudo (inclusive dos personagens). Fonte POSICIONADA: luminária (cone + poça no chão), janela * (raios em diagonal + manchas no piso) ou sol (brilho quente). Contraste quente (luz) × frio (sombra). * `light: "vignette"` escurece as bordas; `"none"` desliga; sem `light`, a fonte sai das peças do lugar. */ export function LightLayer({ light, palette: id, spec }: { light: ShotSpec["light"]; palette?: PaletteId; spec?: ShotSpec }) { const pal = palette(id ?? spec?.palette); const src = resolveLight(spec, light); const vignette = light === "vignette"; if (!src && !vignette) return null; const indoor = !!spec?.place?.indoor; const horizon = spec?.place ? (spec.place.horizon ?? (indoor ? 0.62 : 0.56)) * H : H * 0.6; const night = isNight(id ?? spec?.palette); const warm = night && src?.kind === "window" ? "#a8c0ff" : pal.light; const layers: React.ReactNode[] = []; const defs: React.ReactNode[] = []; if (src?.kind === "lamp") { const floorY = indoor || !spec?.place ? Math.max(src.y + H * 0.3, horizon + (H - horizon) * 0.55) : H * 0.84; const sw = src.spread ?? W * 0.08; const spread = (floorY - src.y) * 0.42 + sw; defs.push( ); defs.push(); defs.push( ); layers.push(); layers.push(); layers.push(); if (src.fixture) { layers.push(); layers.push(); } } else if (src?.kind === "window") { const ww = src.w ?? W * 0.3; const wh = src.h ?? H * 0.18; const x0 = src.x - ww / 2; const y0 = src.y - wh / 2; const dir = src.x < W / 2 ? 1 : -1; const vx = dir * W * 0.78; const vy = H * 0.55; const pane = (a: number, b: number) => { // Retângulo da vidraça arrastado na direção dos raios (contorno convexo). const xa = x0 + ww * a; const xb = x0 + ww * b; const [l, r] = dir > 0 ? [xa, xb] : [xb, xa]; return `${l},${y0} ${r},${y0} ${r + vx},${y0 + vy} ${r + vx},${y0 + wh + vy} ${l + vx},${y0 + wh + vy} ${l},${y0 + wh}`; }; defs.push( ); defs.push( ); defs.push( 0 ? 1 : 0} y1="0" x2={dir > 0 ? 0 : 1} y2="0"> ); layers.push(); layers.push(); layers.push(); layers.push(); // Manchas da janela no piso, inclinadas no sentido dos raios. const fy = horizon + (H - horizon) * 0.3; const fh = (H - horizon) * 0.2; const cx = src.x + dir * W * 0.38; const sk = dir * fh * 0.9; for (const [a, b] of [[-0.62, -0.03], [0.03, 0.62]]) { const xa = cx + ww * a; const xb = cx + ww * b; layers.push(); } } else if (src?.kind === "glow") { const r = Math.max(W * 0.35, src.spread ?? W * 0.4); defs.push( ); defs.push( ); layers.push(); layers.push(); } else if (src?.kind === "sun") { defs.push( ); defs.push( ); layers.push(); layers.push(); } if (vignette) { defs.push(); layers.push(); } return ( {defs} {layers} ); } /** Chuva por cima de tudo (inclusive dos personagens); tempestade escurece, chove mais e relampeja. */ export function WeatherLayer({ spec, frame }: { spec: ShotSpec; frame: number }) { const weather = spec.place?.weather ?? "none"; if (weather === "none") return null; const storm = weather === "storm"; const rand = rng(spec.seed + 101); const drops = Array.from({ length: storm ? 230 : 130 }, () => ({ x: rand() * (W + 300), y: rand() * H, v: 38 + rand() * 26, l: 40 + rand() * 50 })); // Relâmpago: um clarão curto a cada 2,5 s, com fase que depende da semente. const cycle = 75; const ph = (frame + (spec.seed % cycle)) % cycle; const flash = storm && ph < 5 ? (ph < 2 ? 0.55 : 0.25) : 0; return ( {storm && } {drops.map((d, i) => { const y = ((d.y + frame * d.v) % (H + 120)) - 60; const x = ((((d.x - frame * d.v * 0.22) % (W + 300)) + W + 300) % (W + 300)) - 150; return ; })} {flash > 0 && <> } ); } /** * Por cima dos personagens: a parte da frente das peças ocupadas (casco da arca, lataria do carro), na mesma * posição da peça no fundo — quem está "dentro" aparece da cintura para cima. */ export function PlaceForeground({ spec, frame, progress = 0 }: { spec: ShotSpec; frame: number; progress?: number }) { const place = spec.place; const layout = React.useMemo(() => (place ? layoutPlace(spec) : null), [spec, place]); if (!place || !layout || !place.elements.some((e) => e.occupied && FRONT_PART[e.kind])) return null; const pal = palette(spec.palette); const hazeColor = place.indoor ? pal.wall : mix(mix(pal.sky[2], pal.sky[1], 0.25), "#c8ccd6", place.fog ? 0.45 : 0); const level = floodLevel(place, progress); const waterY = level === null ? null : level * H; const storm = place.weather === "storm"; const { horizon, zoom } = layout; const zoomT = zoom === 1 ? undefined : `translate(${W / 2} ${horizon}) scale(${zoom}) translate(${-W / 2} ${-horizon})`; return ( {layout.items.filter((it) => it.e.occupied && FRONT_PART[it.e.kind]).map((it) => { const floating = !!it.e.float && waterY !== null; return ; })} {waterY !== null && place.elements.some((e) => e.occupied && e.float) && } ); }