"Un glosario es un mapa del tesoro: cada término es una X que marca dónde empezar a cavar."
— Frase que apareció en la contraportada de un libro de OOP de los 90 y que sigue siendo verdad.
Este anexo reúne, en orden alfabético, los 500+ términos que aparecen a lo largo del libro. Es un documento vivo: si encuentras uno que falta, anótalo y añádelo en tu copia. Las definiciones son intencionalmente cortas (1-2 líneas) para servir de cheat sheet, no de enciclopedia. Para profundidad, busca el capítulo indicado entre paréntesis.
**Glosario**: lista alfabética de términos con sus definiciones. En libros técnicos funciona como diccionario rápido; en código, como el autocompletado que te evita leer Stack Overflow.AABB (Axis-Aligned Bounding Box): rectángulo delimitador alineado a los ejes (no rotado). Se usa para colisiones rápidas en 2D: dos AABB colisionan si sus rangos X e Y se solapan. (Caps. 5, 28)
Abstracción: ocultar detalles de implementación detrás de una interfaz. En Rust, un trait es la abstracción canónica.
Accesibilidad (a11y): práctica de hacer un juego usable por personas con discapacidad. Subtítulos, remapeo de teclas, modo daltónico.
add_systems: API de App para registrar sistemas en un schedule (Update, FixedUpdate, etc.). Variantes: .chain(), .before(), .after(), .in_set(). (Cap. 3)
add_plugins: API de App para añadir uno o varios Plugin. Acepta tuplas: app.add_plugins((A, B, C)). (Cap. 27)
init_state::<T>(): API actual de App para registrar un enum que deriva States como estado global del juego. (Cap. 28). Nota: add_state::<T>() está deprecado desde hace varias versiones; usar siempre init_state.
Agente: entidad con percepción, decisión y acción. En IA, opuesta a un objeto pasivo. (Cap. 21)
Algoritmo: secuencia finita y determinada de pasos para resolver un problema. En juegos: A*, FSM, BT, RRT, Dijkstra.
Align: componente 2D para alinear un nodo UI a un eje (Center, Start, End). Vive en bevy_ui. (Cap. 14)
Allocation: reserva de memoria. En Rust se distingue entre stack (rápido, tamaño fijo) y heap (lento, dinámico).
Anchor (Anchor en Bevy): punto de pivote de un sprite o texto (Center, TopLeft, etc.). En 0.15+ es un required component de Sprite y Text2d.
Anatomy of a game: estructura clásica — bucle principal, estado, render, input, audio. (Cap. 3)
Animation pipeline: pipeline que toma frames de un atlas y los muestra secuencialmente. En Bevy, AnimationPlayer y TextureAtlas. (Cap. 14)
Anti-aliasing (AA): técnica para suavizar bordes de polígonos. En 2D, MSAA o FXAA. Bevy trae MSAA configurable.
App: estructura raíz de Bevy que contiene el World, los Schedules y la configuración. Equivale a "el juego entero". (Cap. 3)
Árbol de comportamiento (BT): estructura jerárquica de nodos de decisión para IA. Alternativa a FSM para comportamientos complejos. (Cap. 21)
Asset: recurso cargable en tiempo de ejecución (textura, mesh, sonido). En Bevy, gestionado por Assets<T> y AssetServer. (Caps. 6, 14)
AssetServer: recurso que carga assets desde disco (asset_server.load("player.png")). (Cap. 6)
Assets<T>: recurso que contiene los assets cargados en RAM, indexados por Handle<T>. (Cap. 6)
Atlas / Texture atlas: imagen única que contiene varios sprites. Reduce cambios de estado de GPU.
Atomic: tipo con operaciones indivisibles (AtomicU32). Útil para flags lock-free entre hilos.
AudioSink: handle para controlar un sonido en reproducción (volumen, pitch, pausa). Bevy usa bevy_audio.
Behavior Tree (BT): ver Árbol de comportamiento. (Cap. 21)
Benchmark: prueba de rendimiento. En Rust, cargo bench ejecuta benchmarks con criterion.
Bevy: motor de juegos open-source escrito en Rust, basado en ECS. Primera versión pública: 0.1 en 2020.
Bevy Asset Protocol: sistema para cargar tipos de asset personalizados. Define AssetLoader.
Bevy Assets (community): sitio web con assets gratuitos hechos por la comunidad para Bevy.
bevy::prelude: módulo que reexporta los tipos más usados. use bevy::prelude::* es casi obligatorio.
Bevy Renderer: motor de render basado en wgpu. Usa render graph as-systems desde 0.16.
Bevy Schedule Graphs: visualizador de dependencias entre sistemas. Herramienta externa bevy_inspector_egui.
Bevy UI: sistema de UI inmediata declarativa, con nodos y flex layout. (Cap. 14)
Binary (bin): ejecutable. Un crate puede tener varios [[bin]] (ver M8 del cap. 28).
Binding: mapeo de input → acción. En Bevy se hace manual con ButtonInput<KeyCode> o con un plugin de input como leafwing-input-manager o bevy_enhanced_input.
BLS (Bevy Loading State): macro que automatiza la carga de assets en una pantalla de carga.
BNF (Backus-Naur Form): notación para describir gramáticas de lenguajes. Útil para scripting de IA.
Bucle principal: ciclo que ejecuta input → update → render hasta cerrar. En Bevy, App::run() lo implementa.
Builder pattern: patrón de diseño donde un objeto se construye paso a paso. Bevy lo usa en Transform::from_xyz().with_scale(...).
Bundle: grupo de componentes que suelen ir juntos (e.g. SpriteBundle, Camera2dBundle). Desde 0.15, required components reemplazan en muchos casos.
Buffer: zona de memoria para datos. En juegos, frame buffer, vertex buffer, audio buffer.
Bumping (versión): estrategia para subir versión menor (0.13 → 0.14) en Rust: cargo update -p bevy --precise 0.14.0.
Bundle vs Required Components: los required components (cap. 8) reemplazan bundles en muchos casos, evitando errores de duplicación.
Cache miss: cuando la CPU pide datos que no están en caché. Enemigo mortal del rendimiento.
Camera 2D: en Bevy 0.13+, Camera2d añade automáticamente proyección ortográfica. (Cap. 14)
Cargo: gestor de paquetes y builds de Rust. cargo build, cargo run, cargo test, cargo doc.
Cargo features: flags que activan partes opcionales de un crate. Bevy reorganizó las suyas en 0.16.
Cargo workspace: conjunto de crates bajo un Cargo.toml raíz con members = [...]. (Cap. 28)
Cargo.toml: manifiesto del crate. Define nombre, versión, dependencias, features.
CDN (Content Delivery Network): red de servidores para distribuir assets con baja latencia.
CGA (Color Graphics Adapter): estándar gráfico de IBM 1981, 4 colores. Los arcades venían de aquí.
Channel: primitiva de comunicación entre hilos. En Rust, mpsc::channel, crossbeam_channel.
Chase (FSM): estado de IA en el que el enemigo persigue al jugador. Opuesto a Flee. (Caps. 1, 20)
Child entity: entidad hija de otra. Útil para transformaciones jerárquicas (mano → brazo → cuerpo).
ChildOf: relación parent-child introducida en 0.15 (sobre el sistema de Relations). Sustituye al viejo Parent + Children separados. Relations como feature estable general llegó en 0.16/0.17.
Clamp: limitar un valor a un rango. x.clamp(min, max) en Rust estándar.
Class (OOP): molde de objetos con datos y métodos. En Rust, no existe; usamos struct + impl.
Color (Bevy): tipo de color en espacio lineal (0.0-1.0). Color::srgb(r, g, b) para espacio sRGB.
ColorMaterial: material 2D simple con color sólido. Para shaders, implementar el trait Material2d.
Material2d: TRAIT (no componente) en bevy::sprite::Material2d. Define cómo se renderiza una superficie 2D con shaders WGSL. El componente que se inserta en la entidad es MeshMaterial2d<T>, no Material2d. Se registra con Material2dPlugin::<T>. (Caps. 14, 16)
Collision detection: detectar si dos entidades se solapan. Tipos: AABB, círculo, polígono, GJK.
Collision response: reacción tras una colisión: parar, rebotar, daño, trigger.
Command (ECS): ver Commands.
Commands: API para hacer cambios estructurales en el World. Spawn, despawn, insertar/quitar componentes. (Cap. 3)
Community (Bevy): Discord oficial con miles de usuarios, canal #beginners, #help, #showcase.
Compile time: tiempo de compilación. Bevy es famoso por ser lento compilando — usa mold o lld como linkers.
Component (ECS): dato que se asocia a una entidad. En Bevy, cualquier tipo que derive Component. (Caps. 1, 3, 8)
Component Hooks: lifecycle de un componente (on_add, on_insert, on_discard, on_remove). En 0.19, on_replace fue renombrado a on_discard (PR #22789). Desde 0.14. (Cap. 9)
Composition (OOP): construir objetos combinando piezas pequeñas. En ECS, composición pura: una entidad es la suma de sus componentes.
Concurrency: ejecutar varias cosas a la vez. En Rust, threads, async, rayon.
Const generics: parámetros de tipo que son valores. Array<T, N> con N: usize.
Const fn: función evaluable en tiempo de compilación.
Constraint: condición que un sistema debe respetar (e.g. orden de ejecución).
Controller (gamepad): dispositivo de entrada. Bevy lo expone como Gamepad + GamepadButton.
Cooldown: tiempo mínimo entre dos acciones. Evita disparar cada frame.
Coroutine: función que puede pausarse y reanudarse. En Rust, generadores asíncronos.
Coverage: medida de cuánto código ejecutan los tests. cargo tarpaulin lo mide.
CPU (Central Processing Unit): cerebro del ordenador. Juegos single-threaded saturan un núcleo; multithread escala.
CRDT (Conflict-free Replicated Data Type): estructura de datos para sincronizar estado entre clientes sin servidor central. Útil en multiplayer.
Crate: unidad de compilación en Rust. Biblioteca o binario. cargo new --lib o --bin.
Crate.io (crates.io): registro público de crates de Rust.
Crowd simulation: simulación de grupos grandes de NPCs. Estilo Warhammer o Cities.
Cycle (en Bevy): periodo del bucle principal: input, update, render.
DAG (Directed Acyclic Graph): grafo dirigido sin ciclos. Los schedules de Bevy se compilan a un DAG.
Data-driven: diseño donde los datos (no el código) definen el comportamiento. Tilemaps, animaciones, IA.
Deadlock: dos hilos esperan el uno al otro eternamente. Rust lo evita en compilación con locks.
Debug draw: dibujar formas auxiliares en pantalla (hitboxes, paths, rayos). Útil para depurar IA.
Default Plugins (Bevy): conjunto de plugins que añade lo básico: window, input, asset, render, audio.
Derivación (Rust): macro que genera impl automáticamente. #[derive(Debug, Clone)].
Despawn: eliminar una entidad del World. commands.entity(e).despawn() o despawn_recursive().
Determinismo: propiedad de un sistema de producir el mismo resultado dado el mismo input. Crítico para replays y multiplayer lockstep.
Dirty flag: marca que indica que un dato necesita recomputarse. Patrón de optimización clásico.
Discovery (assets): Bevy busca archivos en la carpeta assets/ (configurable).
Distribución (Rust): compilar para otra plataforma. cargo build --target x86_64-pc-windows-msvc.
Doc tests: ejemplos en comentarios de Rust que se ejecutan como tests. cargo test --doc.
DOTS (Data-Oriented Tech Stack): arquitectura de Unity basada en ECS. Conceptualmente similar a Bevy.
Draw call: cada vez que la GPU recibe una orden de dibujo. Reducir draw calls = más FPS.
ECS (Entity-Component-System): patrón de arquitectura donde los datos (componentes) están separados de la lógica (sistemas). (Caps. 1, 3)
Edge (grafo): conexión entre dos nodos. En pathfinding, conexión entre celdas.
Editor: herramienta visual para diseñar escenas. Bevy aún no trae editor oficial; opciones: bevy_editor_pls.
Easing: función de interpolación no lineal (ease-in, ease-out, elastic). Da game feel.
ECS Design (Bevy): ver ECS.
Effect (shader): en wgpu/Bevy, un shader compilado a SPIR-V o WGSL.
Entity: ID opaco de un "objeto" en el World. Las entidades no contienen datos; los componentes sí.
EntityRef: vista inmutable de una entidad y sus componentes. Se obtiene con world.entity(e).
EntityMut: vista mutable. world.entity_mut(e).
Event (Bevy): mensaje entre sistemas. EventReader<T> consume, EventWriter<T> produce. (Cap. 10)
Event loop: bucle que procesa input del SO. En Bevy, abstraído por winit.
EventReader<T>: sistema que recibe eventos de tipo T. Itera con .read(). (Cap. 10)
EventWriter<T>: sistema que envía eventos. Llama a .send(...) o .send_batch(...).
Exception: error en tiempo de ejecución. En Rust, panic. No hay try/catch.
ExecutionOrderHint: Bevy 0.14+ usa .before()/.after() en vez de add_system_after(a, b).
Failure (Rust): tipo Result<T, E> donde E: Error. Patrón idiomático en APIs.
Fallible: función que puede fallar. Devuelve Result, no panic.
Feature flag: ver Cargo features.
Fibre (scheduler): unidad mínima de ejecución. En Bevy, un system.
Field (struct): dato dentro de un struct. struct Player { hp: u32 }.
File system: estructura de carpetas. Bevy espera assets/ en la raíz.
Filter (Query): predicado sobre los componentes. Query<&Transform, With<Player>>.
Finite State Machine (FSM): ver FSM.
Fixed timestep: actualización a intervalos regulares (e.g. 60 Hz físicos). En Bevy, FixedUpdate. (Cap. 18)
FixedUpdate: schedule de Bevy para lógica que necesita paso fijo. Diferente de Update.
Flag: valor booleano. En Rust, bool. En bits, bitflags.
Flash (efecto): pantalla blanca breve al recibir daño. Patrón de game feel.
Float: número con coma flotante. f32 (32 bits) o f64 (64 bits).
Flow field: vector field usado para movimiento de grupos. Estilo Command & Conquer.
Flush (ECS): aplicar las Commands acumuladas. Pasa al final de cada sistema, en ApplyDeferred.
fn (Rust): declaración de función. fn move_player(...).
for<'a> (HRTB): sintaxis para lifetimes de orden superior. Aparece en plugins avanzados.
Frame: un ciclo del bucle de juego. A 60 FPS, 16.67 ms por frame.
Frame buffer: memoria de la imagen antes de mostrarla en pantalla.
Frame rate: frames por segundo. 60 FPS es el estándar; 30 es la consola mínima.
Free list: estructura de datos para reciclar IDs. Bevy usa una para Entity.
FSM (Finite State Machine): máquina con estados finitos y transiciones. Patrón rey de la IA simple. (Caps. 1, 20)
Función pura: función sin efectos secundarios, determinista. Más fácil de testear.
Future (async): valor que se completará en el futuro. Sintaxis async fn.
Game feel: la "textura" de las acciones: respuesta, animación, audio. Más importante que la calidad del pixel art.
Game loop: bucle principal. while running { update(); render(); }.
Game state: estado global del juego (Menu, Playing, Paused, GameOver). (Cap. 28)
Gameplay: la lógica que define qué hace el juego. Distinta del motor.
Garbage collector (GC): gestión automática de memoria. Rust no tiene GC; usa ownership.
Gaussian blur: filtro de desenfoque. Se usa en postprocesado.
Generic (Rust): tipo parametrizado. Component<T> permite componentes con payload.
Geometry: matemática de formas. En 2D, rectángulos, círculos, polígonos.
get_single / get_single_mut: pide exactamente una entidad en la query. Falla si hay 0 o >1.
ggez: motor de juegos 2D en Rust, anterior a Bevy. Sigue activo pero menos popular.
Gizmos: API de Bevy para dibujar líneas y formas de debug. gizmos.rect(...).
GLB / GLTF: formato de modelos 3D. Bevy lo soporta vía bevy_gltf.
Global transform: posición en el mundo. Componente Transform de una entidad raíz.
GPU (Graphics Processing Unit): procesador paralelo, ideal para render.
Gradient: transición suave entre colores. En Bevy, LinearGradient para UI.
Graph (data structure): nodos conectados por aristas. Usado en pathfinding.
GUI (Graphical User Interface): interfaz visual. En juegos, HUD y menús.
glam: librería de matemáticas 3D/2D en Rust. Bevy la usa internamente.
Grid: rejilla. Tilemaps son grids.
Handle: referencia opaca a un asset. Handle<Image>, Handle<Mesh>. Se clona barato.
Hashing: convertir datos en un número fijo. HashMap<K, V> requiere K: Hash.
HashMap: tabla hash. O(1) promedio para get/insert.
HDR (High Dynamic Range): color con valores >1.0. Para efectos de luz.
Header (archivo): parte superior de un archivo de código. En Rust, los use van arriba.
Heatmap: visualización de datos con colores. Útil para profiling.
Hexagonal grid: rejilla hexagonal. Común en juegos de estrategia. Más complejo que cuadrado.
Hitbox: rectángulo de colisión de una entidad. (Cap. 28)
Hook: función que se ejecuta cuando un componente se añade, inserta, descarta o quita. (Cap. 9)
HSL / HSV: modelos de color alternativos a RGB. Útiles para variantes de color.
HUD (Heads-Up Display): interfaz superpuesta al juego. Vida, munición, minimapa. (Caps. 14, 28)
ID: identificador único. En ECS, Entity es un ID.
I/O: input/output. Lectura de disco, red, etc.
ImGUI: GUI inmediata. Bevy tiene bevy_egui como integración.
Immutability (Rust): por defecto, las variables son inmutables. let x = 5; no se puede reasignar.
Inheritance (OOP): relación "es-un". Rust no tiene herencia; usa composición.
Initial state: estado de partida. En juegos RTS, posición y recursos iniciales.
Inlining: el compilador copia el cuerpo de una función donde se llama. Mejora rendimiento.
Input: entradas del usuario. Teclado, ratón, gamepad, touch. (Cap. 19)
Input<KeyCode>: en Bevy 0.13 era la API; desde 0.14 es ButtonInput<KeyCode>.
Instance (ECS): una entidad concreta con sus componentes.
Integration (tests): tests que verifican la interacción entre módulos.
Interpolation: ver lerp.
Intrusive: estructura que modifica el dato del usuario. En ECS Bevy es no intrusivo: los componentes son tipos del usuario.
Inventory: lista de items del jugador. Típico en RPGs.
Inverse kinematics (IK): cálculo de ángulos de articulación para alcanzar un punto. Común en 3D.
iOS: sistema de Apple. Bevy compila a iOS con cargo build --target aarch64-apple-ios.
Iteration (Rust): recorrer una colección. for x in &vec { ... }.
Iterator: objeto que produce una secuencia de valores. vec.iter().filter(...).
Job system: Bevy usa tasks asíncronas internamente (con async-compute o similar).
Join (query): Query<(&A, &B)> une componentes en una sola iteración.
JSON: formato de datos texto. serde_json lo lee/escribe.
JustPressed: input que se activa un solo frame al pulsar. (Cap. 28)
Kernel (OS): núcleo del sistema. Bevy usa winit para abstraerlo.
KeyCode: enumeración de teclas. KeyCode::Space, KeyCode::ArrowLeft. (Cap. 19)
Killing floor (efecto): enemigo muerto que se desvanece. Patrón de animación.
Knockback: empuje al recibir daño. Mejora game feel.
Latency: tiempo entre input y respuesta visible. Crítico en juegos online.
Layer: en render, capa de dibujo. En 2D Bevy, Transform::translation.z define el orden.
Layout (UI): disposición de nodos. Bevy usa flex similar a CSS.
Lazy: evaluación perezosa. En Rust, OnceCell, LazyLock (1.80+).
Leak (memoria): memoria reservada y nunca liberada. En Rust, difícil pero posible con Box::leak.
Lerp: linear interpolation. a + (b - a) * t. (Cap. 28)
Library (lib): crate que produce una .rlib consumida por otros.
Lifetime (Rust): anotación de cuánto vive una referencia. 'a, 'static.
Lighting: iluminación de escena. Bevy 2D soporta luces puntuales y direccionales.
Linker: programa que une objetos compilados. lld, mold son alternativas rápidas a ld.
Load (assets): cargar un asset de disco a memoria. Asíncrono con AssetServer.
Local (ECS): dato de sistema, no de entidad. Marcado con Local<T> en el parámetro del sistema.
Lock (sync): mutex. Mutex<T>, RwLock<T>.
Lua: lenguaje de scripting popular en juegos. Bevy no integra Lua por defecto; opciones: bevy_lua, mlua.
Macro (Rust): código que genera código. #[derive(Debug)], vec![].
Main thread: hilo donde corre Update. Sistemas Bevy corren aquí por defecto.
Marching squares: algoritmo para extraer contornos de un campo escalar. Útil para mapas.
Marker component: componente sin datos, usado como etiqueta. #[derive(Component)] struct Enemy.
Mass: propiedad física. Multiplica fuerza para obtener aceleración.
Match (Rust): pattern matching. match x { 0 => ..., _ => ... }.
Material: en render, descripción de cómo se dibuja una superficie. ColorMaterial, StandardMaterial.
Matrix: arreglo 2D. En gráficos, matriz de transformación 4x4.
Mesh: geometría de un objeto. Mesh2d en 2D, Mesh3d en 3D.
Message passing: comunicación entre sistemas vía eventos. Alternativa a estado compartido.
Metadata: datos sobre datos. En archivos, tags o headers.
Method (Rust): función dentro de un impl. impl Player { fn jump(&mut self) {...} }.
Milestone: hito con demo jugable. (Cap. 28)
MinGW: toolchain Windows para GCC. Bevy en Windows usa MSVC por defecto.
Mock (test): objeto falso para tests. En Rust, mockall.
Module (Rust): archivo o carpeta con código agrupado. mod enemy;.
Monomorphization: el compilador genera una versión especializada por cada tipo genérico usado.
Mouse: dispositivo de entrada. Bevy lo expone como MouseButton + posición.
Movement (sistemas): sistemas que actualizan Transform desde velocidad. (Caps. 5, 28)
MSAA (Multi-Sample Anti-Aliasing): técnica de suavizado. Configurable en Msaa::Sample4.
Mutable (Rust): let mut x = 5; permite reasignación. Por defecto Rust es inmutable.
Mutex: exclusión mutua. Mutex<T> permite acceso sincronizado.
NaN (Not a Number): resultado inválido de operaciones flotantes (e.g. 0.0 / 0.0). f32::NAN.
Native client: juego que corre como app nativa, no en navegador. Bevy es nativo.
Navigation mesh (NavMesh): malla por donde los agentes pueden caminar. Algoritmos: A*, Funnel.
Network: comunicación entre procesos. Bevy no trae red integrada; opciones: bevy_renet, bevy_replicon.
NextState: ResMut<NextState<T>> para cambiar de estado. (Cap. 28)
Node (UI): elemento de UI en Bevy. Node + hijos.
Noise: función pseudoaleatoria para generación procedural. noise crate, Perlin, Simplex.
NPC (Non-Player Character): personaje controlado por la IA, no por el jugador.
Observer (Bevy): sistema que reacciona a eventos sobre una entidad específica. (Cap. 10)
OnAdd / OnInsert / OnRemove: eventos de ciclo de vida para observers (trigger). En 0.19 el hook intermedio de "antes de descartar" se llama on_discard (renombrado de on_replace en el PR #22789). (Cap. 9)
OnEnter / OnExit: schedules que se ejecutan al entrar/salir de un estado. (Cap. 28)
Opacity: transparencia. En Bevy, Color::with_alpha().
OpenGL: API gráfica antigua. Bevy usa wgpu (Vulkan/Metal/DX12/WebGPU).
Optimization: mejorar rendimiento. Profilear antes de optimizar.
Option<T>: tipo que puede ser Some(T) o None. Idiomático en Rust para nullables.
Order (sistemas): orden de ejecución entre sistemas. .before(), .after(), .chain().
Orthographic camera: cámara sin perspectiva, usada en 2D. (Cap. 14)
OS (Operating System): sistema operativo. Bevy soporta Windows, macOS, Linux, iOS, Android, Web.
Output (render): imagen final por frame. Típicamente 1080p o 720p.
Owner: en Rust, la variable que posee un valor. Reglas de ownership.
Package (Cargo): ver crate.
Paint: dibujar píxeles en pantalla. La fase final del render.
Pairing (Bevy 0.16): relación explícita entre dos entidades. Pair(Enemy, Player) indica "este enemigo tiene a este jugador como target".
Parallelism: ejecutar a la vez. Bevy paraleliza sistemas automáticamente cuando no hay dependencias.
Param (Sistema): tipo que un sistema puede pedir como parámetro. Query, Res, ResMut, EventReader, Commands. (Cap. 3)
Patch (versión): tercer dígito en semver (0.19.1). Cambios compatibles.
Pathfinding: encontrar camino entre dos puntos. A* es el rey. (Cap. 22)
Pattern (diseño): solución reutilizable a un problema común. FSM, Observer, Singleton.
Pause: estado de juego donde Update no avanza. Típico con GameState::Paused.
Performance: ver rendimiento.
Physics: simulación de fuerzas, colisiones, gravedad. Bevy no trae física por defecto; opciones: bevy_rapier, bevy_avian.
Pitch (audio): frecuencia del sonido. Más agudo = más Hz.
Pivot: punto de anclaje para rotación/escala. Anchor::Center.
Pixel: unidad mínima de imagen. En 2D, todo se mide en píxeles.
Plugin (Bevy): unidad modular de funcionalidad. Implementa el trait Plugin. (Cap. 27)
PluginGroup: grupo de plugins que se registran juntos. (Cap. 27)
Polygon: figura cerrada de N lados. En 2D, bevy_prototype_2d_polyline.
Pool (de objetos): reutilización de objetos para evitar allocations. bevy_utils.
Position: típicamente Vec3 con (x, y, z). En 2D, z=0.
Power-up: objeto que da una habilidad nueva. Típico en metroidvania. (Cap. 28)
Pre-processor: en C, transforma el código antes de compilar. Rust tiene macros en su lugar.
Predicate: función que devuelve bool. Query::filter().
Procedural generation: contenido generado por código. (Caps. 27, 28)
Profiler: herramienta para medir rendimiento. tracy, puffin, optick.
Projection: cómo 3D se mapea a 2D en la pantalla. Ortográfica vs perspectiva.
Property: ver field.
Pull-based (ECS): los sistemas preguntan al mundo. Bevy es pull-based.
Push-based (ECS): el mundo empuja actualizaciones. Bevy soporta esto con observers (0.14+). (Cap. 10)
Quadtree: estructura espacial que divide el espacio en cuadrantes. Útil para colisiones masivas.
Query (Bevy): API para iterar entidades con ciertos componentes. Query<&Transform, With<Player>>. (Cap. 3)
Queue: estructura FIFO. VecDeque<T> en Rust.
Quicksort: algoritmo de ordenación O(n log n). slice::sort_unstable.
Radianes: unidad angular. f32::to_radians(180.0) = π.
Rapier: motor de física 2D/3D en Rust. Integración: bevy_rapier.
Raycast: trazar una línea y ver qué choca. Útil para line of sight de IA.
Reactive (ECS): patrón donde los datos cambian y los sistemas reaccionan. Bevy observers. (Cap. 10)
Read (sistema): Query<&T> o Res<T>. Inmutable.
Real-time: ejecutar con latencia mínima. Juegos son real-time.
Refactor: reescribir código sin cambiar comportamiento. Bevy 0.13→0.19 fue varios refactors.
Region: zona del mapa. Común en RPGs.
Registry: ver HashMap.
Relation (Bevy): conexión tipada entre entidades. Introducida en 0.15. (Cap. 11)
Render: fase de dibujo. En Bevy, sistemas del schedule Render.
Render graph: grafo de pases de render. Bevy 0.16+ lo expone como sistemas.
Render target: textura donde se dibuja. Por defecto, la ventana.
RenderApp: sub-app de Bevy dedicada al render. Corre en un hilo separado.
Required Component: componente que se inserta automáticamente al añadir otro. (Cap. 8)
Res<T> / ResMut<T>: acceso a recursos. (Cap. 3)
Resource (Bevy): dato global del juego. Cualquier tipo que derive Resource. (Caps. 3, 6)
Return: fn foo() -> i32 { 42 }.
Robustness: capacidad de manejar entradas inválidas sin crashear.
Rolling update: actualizar sin cerrar el juego. Bevy tiene hot-reload parcial.
run (App): arranca el bucle. App::new()...run().
Rust: lenguaje de programación de Mozilla. Bevy está escrito en él.
Rust Analyzer: extensión de IDE para Rust. Da autocomplete y errores en vivo.
Sample (audio): dato de audio en un instante. 44.1 kHz = 44100 muestras/segundo.
Save: estado persistido en disco. Bevy no trae save integrado; opciones: bevy_pkv, bevy_save.
Scalar: número único. f32, i32.
Scale: tamaño relativo. Transform::scale = Vec3::splat(2.0).
Scene: archivo que describe un conjunto de entidades. .scn (Bevy) o .tscn (Godot).
Schedule: lista ordenada de sistemas a ejecutar. Update, FixedUpdate, Startup. (Cap. 3)
Schedule graphs: visualización de dependencias. Herramienta externa.
Scope: rango de visibilidad. let x = 5; { let y = 6; } — y no sale del bloque.
Screen space: coordenadas de pantalla. (0,0) arriba a la izquierda.
Scripting: lógica de juego escrita en un lenguaje interpretado (Lua, Python). Bevy prefiere Rust.
Sealed trait: trait que no se puede implementar fuera del módulo.
Seed: valor inicial de un generador aleatorio. rand::SeedableRng::seed_from_u64(42).
Semver (Semantic Versioning): formato MAJOR.MINOR.PATCH. Bevy usa 0.MINOR.PATCH.
Send / Sync (traits): marcan tipos como seguros para enviar entre hilos.
Sensor: collider que detecta pero no choca. Para triggers.
Shader: programa que corre en la GPU. Bevy usa WGSL o GLSL.
Shape: forma geométrica. Rectangle, Circle, Triangle.
Side effect: cambio fuera de la función. En Rust, controladas por &mut.
Singleton: instancia única de algo. En Bevy, recurso o componente con get_single.
Skeleton: jerarquía de huesos para animación. En 2D Bevy se simula con jerarquías.
Slice: vista sobre un array. &[u8].
Sound effect (SFX): efecto de sonido corto. Disparos, saltos, monedas.
Spawn: crear una entidad. commands.spawn(...).
Spatial query: buscar entidades en una región. AABB overlap.
Sprite: imagen 2D. Sprite + Image + Transform.
Sprite sheet: ver texture atlas.
Stack vs heap: dos zonas de memoria. Stack rápido, heap dinámico.
State machine: ver FSM.
Startup: schedule que corre una sola vez al inicio. Para inicialización. (Cap. 3)
Static (lifetime): 'static, vive durante toda la ejecución.
Stat: variable numérica del jugador. HP, MP, XP.
Storage (ECS): cómo Bevy guarda los componentes. Table (rápido añadir/quitar) o SparseSet (iteración rápida).
Strategy: plan de alto nivel en IA. RTS distingue strategy y tactics.
Streaming: cargar assets en tiempo de ejecución. Bevy lo soporta vía AssetServer.
Stress test: prueba bajo carga extrema.
String: texto. String (heap) vs &str (slice).
Struct: tipo de dato compuesto. struct Player { hp: u32 }.
Sub-app: SubApp en Bevy, un App dentro de otro. Usado por RenderApp.
Subsystem: sistema secundario. Audio, networking.
System (ECS): función que opera sobre componentes. (Caps. 1, 3)
SystemParam: trait que define qué puede pedir un sistema.
SystemSet: conjunto de sistemas agrupados lógicamente. SystemSet::new(). (Cap. 27)
Task (async): unidad de trabajo asíncrono. Bevy usa bevy_tasks.
Template (Rust): ver generic.
Test: función que verifica comportamiento. #[test] fn ....
Texture: imagen en GPU. Bevy la maneja como Image.
Thread: hilo de ejecución. Bevy paraleliza sistemas entre threads.
Tile: celda de un tilemap. (Cap. 28)
Tilemap: rejilla de tiles. (Caps. 1, 28)
Time: recurso con delta, elapsed, etc. (Cap. 3)
Tokenizer: convierte texto en tokens. En análisis de scripts.
Trait (Rust): conjunto de métodos que un tipo puede implementar. Component, Resource, Plugin.
Trait object: dyn Trait. Dispatch dinámico.
Transform: posición, rotación, escala. Transform { translation, rotation, scale }. (Cap. 3)
Transition (FSM): cambio de estado. Disparado por condición. (Caps. 1, 20)
Trigger: collider que dispara un evento sin bloquear.
Tuple: agrupación de N valores. (i32, f32).
Turbofish: ::<T> sintaxis para inferir tipos genéricos. Vec::<u8>::new().
Type (Rust): descripción de un dato. struct, enum, trait, primitivos.
UI (User Interface): interfaz gráfica. (Cap. 14)
Unwrap: Option::unwrap() o Result::unwrap(). Panic si es None/Err.
Update: schedule principal de Bevy. Corre cada frame. (Cap. 3)
Update rate: frecuencia de actualización. 60 Hz, 30 Hz.
Upscaling: renderizar a menor resolución y escalar. Aumenta FPS.
Validate: comprobar que los datos son correctos.
Value: dato. En ECS, component value.
Variable: contenedor con nombre. let x = 5;.
Vector: tipo de dato con múltiples componentes. Vec2, Vec3, Vec4.
Velocity: velocidad de una entidad. Componente típico. (Cap. 5)
Vertex: punto en un polígono o mesh.
Visual scripting: programar con nodos gráficos. Bevy no trae.
Voronoi: diagrama de regiones. Útil para pathfinding.
Vulkan: API gráfica moderna. Bevy la usa vía wgpu.
WASM (WebAssembly): bytecode para web. Bevy compila a wasm32-unknown-unknown.
Wave Function Collapse (WFC): algoritmo de generación procedural.
WebGPU: API gráfica para web. Bevy la soporta.
wgpu: librería de Rust que abstrae Vulkan/Metal/DX12/WebGPU.
Window: ventana del SO. Bevy usa winit y Window component.
Workspace (Cargo): ver Cargo workspace.
World: contenedor de entidades y recursos en Bevy. App.world(). (Cap. 3)
Write (sistema): Query<&mut T> o ResMut<T>.
XOR: operación lógica exclusiva. a ^ b.
X11 / Wayland: protocolos de display en Linux. Bevy soporta ambos.
YAML: formato de serialización. .yaml.
Yield: en Rust async, yield_now() cede el control.
Z-order: orden de dibujo. Transform::translation.z en 2D.
Zero-cost abstraction: principio de Rust: las abstracciones no añaden overhead.
Zeroize: limpiar memoria con ceros. Importante para secretos criptográficos.
Zig: lenguaje de sistemas. No relacionado con Bevy, pero comparte ethos.
mut: palabra clave para hacer una variable mutable.
ref: anotación obsoleta; usar & directamente.
impl: bloque de implementación de un trait o métodos intrínsecos.
Self: alias del tipo actual dentro de un impl.
Self::method(): llamada a un método del tipo actual.
Some / None: variantes de Option<T>.
Ok / Err: variantes de Result<T, E>.
Box<T>: puntero al heap. Box::new(Player { ... }).
Rc<T>: puntero compartido single-threaded. Reference counting.
Arc<T>: Rc pero thread-safe.
Cow<T>: clone-on-write. Cow::Borrowed(&x) o Cow::Owned(x.clone()).
Default: trait para valor por defecto. impl Default for Player { fn default() -> Self {...} }.
Clone: trait para duplicar un valor.
Copy: marcador para tipos copiables bit-a-bit (i32, f32, etc.).
Debug: trait para imprimir con {:?}. Imprescindible para development.
Display: trait para imprimir con {}. Para usuarios.
PartialEq / Eq: igualdad.
PartialOrd / Ord: orden.
Hash: hashing.
Send / Sync: thread safety.
Deref / DerefMut: desreferenciar como otro tipo. Personalizar cómo se ve *x.
From / Into: conversiones. impl From<A> for B.
TryFrom / TryInto: conversiones que pueden fallar.
Iterator: el trait de los iteradores. next() devuelve Option<Item>.
IntoIterator: convierte una colección en iterador.
Drop: destructor. Se llama al salir del scope.
?: operador de propagación de errores.
async / await: funciones asíncronas.
move: transfiere ownership al closure.
dyn: dynamic dispatch. &dyn Trait.
Total de términos: ~550.
BSN (Bevy Scene Notation): sintaxis declarativa de escenas introducida en 0.19, basada en la macro bsn!{}. Reemplaza parcialmente a DynamicScene para escenas en código.
bsn! macro: macro procedural que produce un DynamicScene o un bundle a partir de sintaxis declarativa. Soporta jerarquías, required components, observers inline.
bsn_list![] macro: variante de bsn! para spawnear múltiples entidades independientes de una vez. Útil para oleadas, pickups, decoraciones.
SceneComponent: derive que garantiza que si tu componente está presente, la escena completa que lo define también lo está. Si alguien intenta world.spawn(MyComp::default()), Bevy loggea error. Spawnear correctamente: world.spawn_scene(bsn!{...}).
bevy_simple_subsecond_system: plugin experimental de TheBevyFlock que recompila funciones Bevy en runtime usando Dioxus subsecond. Requiere nightly y dioxus-cli@0.7.0-alpha.1. Hot-patch de sistemas sin reiniciar el binario.
bevy_asset_loader: plugin de NiklasEi para carga declarativa de assets. Trait AssetCollection, LoadingState<AppStates>, ProgressCounter. Estándar de facto en producción.
AssetCollection: trait derivado en un struct para declararlo como colección de assets a cargar juntos.
LoadingState: estado de carga de Bevy gestionado por bevy_asset_loader; transita automáticamente cuando todos los assets están listos.
DynamicAsset: asset cuya ruta se conoce en runtime (i18n, mods, procedurales). Usa dynamic_assets.replace(key, path) para cambiar la ruta y que el plugin recargue.
ProgressCounter: recurso de bevy_asset_loader que mantiene el progreso de carga (.done / .total). Útil para barras de progreso.
bevy_tnua: librería de "character controller" para Bevy. Separa feel (coyote time, jump buffer) de física (Avian/Rapier). Plugins: TnuaControllerPlugin, TnuaAvian2dPlugin.
Coyote time: ventana de tiempo (típicamente 100ms) tras dejar una plataforma en la que el jugador aún puede saltar.
Jump buffer: ventana de tiempo (típicamente 100ms) antes de aterrizar en la que un input de salto se recuerda y se ejecuta al tocar suelo.
TnuaBuiltinWalk: action de Tnua para caminar. Tiene desired_velocity, slope_acceleration, max_slope.
TnuaBuiltinJump: action de Tnua para saltar. Tiene coyote_time, jump_buffer, takeoff_speed_factor (para variable jump height).
bevy_ecs_tilemap: plugin de StarArawn para tilemaps en Bevy. Cada tile es una entidad, los chunks se renderizan con una sola draw call. Compatible con Bevy 0.16 (no 0.18+ al cierre del libro).
TilemapBundle: bundle principal de un tilemap; tiene size, tile_size, grid_size, storage, texture.
TilemapRenderSettings: struct con render_chunk_size (UVec2) y y_sort (bool). Controla el batching y el orden de dibujado.
Chunk (tilemap): agrupación de tiles (típicamente 16x16 o 32x32) que se renderiza con una sola draw call. La clave del rendimiento en tilemaps.
bevy_ecs_ldtk: plugin de Trouv pour cargar archivos .ldtk (LDTK) en Bevy. Convierte capas y entidades LDTK en entities Bevy. Compatible con Bevy 0.16 (no 0.18+ al cierre del libro).
bevy_kira_audio: plugin estándar de audio para Bevy 0.18+. Wrapper sobre la librería Kira. Soporta OGG, MP3, FLAC, WAV, audio espacial 2D, música adaptativa, busses.
bevy_fmod: plugin para integrar FMOD Studio (motor de audio comercial) en Bevy. Soporta audio 3D HRTF, parámetros en tiempo real, live updates. Requiere licencia FMOD (gratis para indie).
leafwing-input-manager (LWIM): plugin de Leafwing Studios para input escalable en Bevy. Traits Actionlike, InputMap, ActionState. Soporta rebind, mock para tests, multiplayer local, scan codes.
Actionlike: trait derivado en un enum para convertirlo en una lista de acciones tipadas. Cada variante puede ser Buttonlike, Axislike, o DualAxislike.
InputMap<A>: resource que asocia cada acción A con uno o más UserInput (botones, ejes, chords). Configurable en runtime.
ActionState<A>: resource con el estado pulsado/pressed/released/axis por acción. Métodos: pressed, just_pressed, just_released, axis_pair.
InputKind: tipo de input en LWIM: Button (digital), Axis (analógico 1D), DualAxis (analógico 2D), TripleAxis (3D).
ButtonlikeChord: combinación simultánea de varios Buttonlike que dispara una acción (ej. Ctrl+Shift+C).
ClashStrategy: política de LWIM para resolver conflictos entre acciones que comparten inputs. PressAll (default) o UseActionOrder (legacy).
Scan code: código físico de la tecla (posición), no su label. KeyCode::KeyW (posición) vs KeyCode::W (lógica). Útil para QWERTY/AZERTY/QWERTZ.
ActionMock: API de LWIM para inyectar input en tests. state.action_data_mut(action).press() simula una pulsación.
ActionDiff: diff entre dos ActionState consecutivos. Útil para sincronizar input por red (solo envías lo que cambió).
bevy_inspector_egui: plugin de jakobhellermann para inspeccionar entities/resources/assets in-game via egui. El "printf del ECS".
WorldInspectorPlugin: plugin drop-in de bevy_inspector_egui que muestra todos los entities en una ventana.
bevy_editor_pls: editor in-app de jakobhellermann. Jerarquía, component inspector, cámara separada, scene export.
space_editor: editor standalone + plugin de rewin123. El más completo de los editores comunitarios. Soporta prefabs, multi-window, asset browser.
bevy_editor: editor oficial first-party de Bevy (experimental en 0.18+). Roadmap en bevyengine/bevy_editor_prototypes. Para 2026-2027 todavía no production-ready.
Blenvy: workflow que usa Blender como editor de niveles para Bevy. Exporta a GLTF con componentes Bevy embebidos. Útil para equipos 3D/2.5D.
bevy_github_ci_template: plantilla oficial de GitHub Actions del Bevy Engine org. CI + release workflows para Linux/Windows/macOS/WASM. Clonar, adaptar, listo.
BevyError: alias de Box<dyn Error + Send + Sync + 'static> usado por sistemas Bevy para retornar errores. BevyError::from acepta cualquier Error.
BevyError::Result: alias de Result<(), BevyError>. El tipo de retorno de sistemas fallibles. set_error_handler(warn) / set_error_handler(error) / etc. configuran el comportamiento.
Trauma² (game feel): técnica de screenshake donde el offset real es trauma² × max_amplitude. La curva cuadrática hace que el shake sea sutil al inicio y exagerado al final. Popularizada por Vlambeer (GDC 2013).
Hitstop: técnica de "freeze frame" en un impacto. Time<Virtual>::set_relative_speed(0.0) pausa el gameplay manteniendo audio/UI. 50-200ms es el rango habitual.
Squash & stretch: principio de animación Disney aplicado a sprites. Estirar Y en saltos, aplastar en aterrizajes, manteniendo el área (volumen visual) constante.
Hit flash: sprite blanco (o de color elemental) durante 50-150ms en daño. Feedback visual inmediato del impacto.
Input lag compensation: feedback visual instantáneo (highlight, partícula) en el mismo frame que se pulsa un botón. Cierra el gap entre input y feedback.
**¿Sabías que…?** El lenguaje Rust debe su nombre al hongo *Puccinia graminis* (roya del trigo), que tiene formas de vida superpuestas (memory safety sin garbage collector). El diseñador Graydon Hoare lo nombró así porque el hongo es "muy resistente y sobrevive donde otros lenguajes se oxidarían". Lo de la ferretería es solo el logo.**Metedura de pata #Z**: leer este glosario de cabo a rabo intentando memorizarlo todo. Nadie memoriza 500 términos de golpe. Úsalo como mapa: cuando un término te suene raro, vuelve aquí. Con el tiempo, los conceptos se quedan solos. Y si no, pues siempre puedes hacer trampa con Ctrl+F.