> For the complete documentation index, see [llms.txt](https://docs.allout.game/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.allout.game/all-out-docs/docs-es/si-vienes-de-otras-herramientas/unreal.md). # Unreal Si has creado juegos con Unreal, hay algunas diferencias clave que necesitarás conocer para empezar en All Out. *** Esta guía es para desarrolladores de Unreal Engine (Blueprints / C++) que están pasando a **All Out** y **CSL** (El lenguaje de scripting personalizado de All Out). ## El gran cambio (modelo mental) En Unreal, a menudo piensas en términos de: * **Actores en un mundo** (generados, replicados, poseídos) * **Componentes** adjuntos a Actores * **Blueprint graphs / C++** impulsando el gameplay * **RPC + replicación** lo defines explícitamente En All Out, normalmente pensarás en términos de: * **Entidades en una escena** (con componentes) * **Componentes** (componentes proporcionados por el motor + tus propios componentes CSL) * **Habilidades** para las acciones del jugador (UI primero para móvil + tiempo de reutilización + apuntado) * **Gameplay compartido y predicho** donde la sincronización de estado es automática (sin infraestructura RPC personalizada para la mayoría del gameplay) * **Transformaciones 2D** using `v2` posición y escala más un ángulo de rotación ## Mapeo rápido: Unreal → All Out / CSL | Unreal | All Out / CSL | Notas | | -------------------------------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | | `UWorld` / Level | `Escena` | Las entidades existen en la escena; también puedes crearlas/destruirlas en tiempo de ejecución. | | `AActor` | **Entidad** | Las entidades tienen transformaciones 2D y componentes. | | Ubicación del actor | `Entity.local_position` / `world_position` | Decide cómo Unreal X/Y/Z se mapea al plano 2D X/Y del juego. | | Rotación del actor | `Entity.local_rotation` | All Out usa un solo ángulo de rotación en grados. | | Escala del actor | `Entity.local_scale` | All Out usa `v2`; no existe escala Z de gameplay. | | `UActorComponent` | `Component` | Defines el gameplay escribiendo componentes CSL y adjuntándolos a entidades. | | `BeginPlay` | `ao_start` | Punto de entrada del ciclo de vida del componente. | | `Tick(float DeltaTime)` | `ao_update(dt)` / `ao_late_update(dt)` | Usa actualización tardía para patrones de UI/entrada usados por el motor (por ejemplo, botones de habilidades). | | Blueprint graphs | Código CSL | Basado en texto, compilado como parte de tu proyecto. | | Pawn/Character | `Player_Base` subclases | La lógica de tu jugador normalmente vive en un `Player` componente/clase. | | Mapeos de entrada | Habilidades + asignaciones de teclas | Prioridad móvil: prefiere botones de habilidades en lugar de entrada cruda. | | Replicación (`Replicado` vars) | Sincronización automática de estado | Escribe una única ruta de gameplay predicha en lugar de versiones separadas de cliente/servidor. | | RPCs (`Servidor`, `Cliente`, `NetMulticast`) | Normalmente no se necesita | Usa las facilidades del motor (por ejemplo, notificaciones) en lugar de una proliferación de RPC personalizados. | | Generación de actores | `Scene.create_entity()` / `Scene.instantiate(Prefab_Asset)` | Los prefabs son assets y pueden instanciarse. | | `UAsset` referencias | `get_asset(...)` | Los assets viven en `/res` y se referencian por ruta. | ## Tu primer archivo CSL (imports) CSL usa un único patrón de importación “raíz”: importa en `main.csl`y no disperses imports en cada archivo. ```go // main.csl import "core:ao" import "ui" // si creas una carpeta /ui y quieres que esté en alcance ``` ## Entidades y componentes (vs Actores y Componentes) ### Creación de una entidad en tiempo de ejecución ```go entity := Scene.create_entity(); entity.set_local_position({10, 20}); entity.set_local_scale({2.0, 2.0}); entity.set_local_rotation(0); ``` ### Añadir y acceder a componentes ```go my := entity.add_component(My_Component); sprite := entity.get_component(Sprite_Renderer); // Destruir la entidad (y sus componentes) entity.destroy(); ``` ### Escribir un componente personalizado (ciclo de vida) ```go Spinner :: class : Component { speed: float; ao_start :: method() { speed = 1.0; } ao_update :: method(dt: float) { entity.set_local_rotation(entity.local_rotation + speed * dt); } } ``` Los procs globales del ciclo de vida se ejecutan en cada simulación de escena participante; no son solo para el servidor. Los clientes que se unan tarde pueden recibir un componente cuyo ciclo de vida de inicio ya se ejecutó, así que reconstruye la presentación a partir del estado sincronizado en `ao_on_state_sync` cuando sea necesario. Consulta [Ciclo de vida del juego/fotograma](/all-out-docs/docs-es/programacion/game-frame-lifecycle.md). ### Iteración de entidades/componentes ```go for e: entity_iterator() { // ... } for p: component_iterator(Player) { // ... } ``` ## Acciones del jugador: usa Habilidades (en lugar de entrada cruda) Los proyectos de Unreal a menudo empiezan con enlaces de entrada (Enhanced Input) y luego construyen la UI/UX encima. En All Out, **Habilidades** son la forma predeterminada de implementar acciones del jugador con: * Una interfaz **compatible con móviles** de botones * Tiempos de reutilización * Apuntado opcional (arrastrar para apuntar en móvil, apuntar con ratón en PC) Dibuja los botones de habilidad desde `Player.ao_late_update` interior de ese jugador `is_local_or_server()`: ```go Player :: class : Player_Base { ao_late_update :: method(dt: float) { if this.is_local_or_server() { draw_ability_button(this, Shoot_Ability, 0); draw_ability_button(this, Dodge_Roll, 1); } } } ``` Ver: [Habilidades](/all-out-docs/docs-es/conceptos-basicos-del-motor/abilities.md) para la API completa y los patrones. ## Red: “la replicación” no es tu trabajo (la mayor parte del tiempo) ### Qué es diferente de la replicación de Unreal * El gameplay normal se ejecuta en el cliente que predice y en el servidor autoritativo. * Generalmente **no escribes RPCs** para flujos estándar de gameplay. * Aun así debes diseñar pensando en **varios jugadores** : evita el estado global; guarda el estado por jugador en la instancia del jugador. * No protejas el gameplay normal con `Game.is_server()` o desactivarás la predicción. ### IU del jugador vs anulaciones visuales locales Usa estos patrones: * `is_local_or_server()` para los **controles + IU de gameplay** * `is_local()` solo para **anulaciones visuales específicas del jugador** ```go Player :: class : Player_Base { ao_late_update :: method(dt: float) { if this.is_local_or_server() { // controles + IU de gameplay } if this.is_local() { // anulaciones visuales que solo este jugador debería ver } } } ``` Ver [Fundamentos de redes](/all-out-docs/docs-es/programacion/networking-fundamentals.md). ## Assets, prefabs y rutas ### El `/res` carpeta Los assets están en `/res`. Al referenciar assets, **omite `/res`** de la ruta. ```go button := get_asset(Texture_Asset, "ui/button.png"); click := get_asset(SFX_Asset, "sfx/click.wav"); font := get_asset(Font_Asset, "$AO/fonts/Barlow-Black.ttf"); // assets del motor ``` ### Prefabs Los prefabs son assets y pueden instanciarse mediante `Escena`: ```go prefab := get_asset(Prefab_Asset, "Enemies/Slime.prefab"); enemy_entity := Scene.instantiate(prefab); ``` ## Eventos de colisión y solapamiento (error común en Unreal) Un collider habilitado con `is_trigger` establecido puede llamar a `on_trigger_start`, `on_trigger_stay`, y `on_trigger_end`. Cada callback recibe el collider del trigger y el otro collider. Un `Movement_Agent` no es necesario. CSL no expone un callback general de impacto sólido equivalente a `OnHit`. Usa un trigger para el comportamiento de solapamiento del gameplay. Para detección amplia, consulta componentes cercanos: ```go nearby: [..]Pickup; Scene.get_all_components_in_range(player_pos, 2.0, ref nearby); for p: nearby { // ... } ``` Ver: [Navmesh y colisión](/all-out-docs/docs-es/conceptos-basicos-del-motor/navmesh-and-collision.md). ## Diferencias de UI (UMG vs UI de CSL) Los juegos de All Out son **prioridad móvil**, así que evita construir una UX solo para teclado. Usa las utilidades de UI del motor y los botones de habilidades. Para UI personalizada, empieza con [Fundamentos de la UI](/all-out-docs/docs-es/ui/fundamentals.md) o [Inicio rápido de UIDoc](/all-out-docs/docs-es/ui/uidoc-quick-start.md). ## Flujo de partida, inventario, interactuables Si buscas equivalentes a sistemas de gameplay comunes de Unreal: * **Interactuables**: [Interactuables](/all-out-docs/docs-es/conceptos-basicos-del-motor/interactables.md) * **Inventory**: [Inventory](/all-out-docs/docs-es/conceptos-basicos-del-motor/inventory.md) * **Emparejamiento / juegos de hub**: [Emparejamiento / juegos de hub](/all-out-docs/docs-es/conceptos-basicos-del-motor/matchmaking-hub-games.md) * **Agentes de movimiento / NPCs**: [Agentes de movimiento / NPCs](/all-out-docs/docs-es/conceptos-basicos-del-motor/movement-agents-npcs.md) * **Animaciones Spine** (si usaste Paper2D / flipbooks): [Spine](/all-out-docs/docs-es/conceptos-basicos-del-motor/spine.md) ## “Trampas” de Unreal a CSL * **No construyas una capa personalizada de RPC/replicación**: empieza con la ruta de gameplay compartida y predicha y deja que el motor sincronice el estado. * **No protejas el gameplay con `Game.is_server()`**: el gameplay normal también debe ejecutarse en el cliente que predice. * **Evita singletons globales para el estado del gameplay**: se conectan varios jugadores; guarda el estado en el jugador o en la instancia del componente relevante. * **Los imports están centralizados**: importa carpetas una sola vez desde `main.csl`, no por archivo. * **Prefiere Habilidades para las acciones**: resuelve de forma consistente la UX móvil + tiempos de reutilización + apuntado. * **Mapea diseños 3D a 2D**: usa capas de renderizado en lugar de una transformación Z. ## Próximos pasos * Lee [Habilidades](/all-out-docs/docs-es/conceptos-basicos-del-motor/abilities.md) * Lee [Navmesh y colisión](/all-out-docs/docs-es/conceptos-basicos-del-motor/navmesh-and-collision.md) * Echa un vistazo [Interactuables](/all-out-docs/docs-es/conceptos-basicos-del-motor/interactables.md) y [Inventory](/all-out-docs/docs-es/conceptos-basicos-del-motor/inventory.md)