Giro de la Suerte: Programación Divina - Capítulo 83

83: Capítulo 83: Terminando Minecraft 83: Capítulo 83: Terminando Minecraft Nota del autor: El recuento de palabras es superior a la media, ya que es demasiado agotador separarlo.

…

Abrió su editor de código y comenzó a asignar responsabilidades, línea por línea, palabra por palabra, ladrillo por ladrillo.

Igual que un general dando órdenes, y él era ese original, digo, general.

Con esto, el servidor sería el dueño del mundo.

Cada árbol, bloque y bioma se generaba aquí.

Construyó el módulo de generación de mundos, asegurándose de que los trozos se crearan de forma consistente y solo se cargaran cuando los jugadores se acercaran.

El servidor se encargaría del trabajo pesado, creando una experiencia fluida a medida que el mundo se expandía con el movimiento de cada jugador.

Cada detalle fue planeado meticulosamente, garantizando la eficiencia y el rendimiento.

Lo siguiente fue el control de bloques.

Los jugadores ya no podían colocar o romper bloques libremente.

Así pues, escribió un script de validación: cada acción tenía que ser aprobada por el servidor antes de que los demás la vieran.

Por lo tanto, no habría trampas ni desincronización.

Luego vino el seguimiento de jugadores.

Cada actualización de posición, salto o esprint se sincronizaba en tiempo real.

Si alguien se movía demasiado rápido, el servidor lo marcaba.

Los hacks de velocidad ya estaban muertos al nacer.

Le siguió la sincronización de inventario.

Jeff conectó las caídas de objetos, las recolecciones y los resultados de fabricación directamente al servidor, asegurando que todo se mantuviera consistente y seguro en toda la experiencia multijugador.

Eso significaba que no habría más manipulación del lado del cliente; cada objeto se ganaba, no se generaba.

Finalmente, conectó el chat y los eventos.

Los jugadores podían escribir y el servidor lo transmitiría a todos.

A continuación, se centró en implementar la Arquitectura Cliente-Servidor.

Abrió el script PlayerController.cs y se quedó mirando la lógica.

Los clientes moverían a sus personajes, pero el servidor tendría la última palabra.

Así que usó la estructura incorporada de Mirror.

Era perfecta, y estaba completamente bajo su control.

Esta configuración garantizaría una comunicación fluida entre el servidor y los clientes, al tiempo que mantendría un control total sobre las mecánicas del juego.

…
Csharp
[Command]
void CmdMove(Vector3 position)
{
transform.position = position;
RpcUpdatePosition(position);
}
[ClientRpc]
void RpcUpdatePosition(Vector3 position)
{
transform.position = position;
}
…
El [Command] le decía al servidor: «Oye, el cliente quiere moverse».

El [ClientRpc] les decía a todos los demás: «Aquí es donde está realmente ese jugador».

Jeff lo probó y, cuando un cliente se movió, el servidor lo confirmó, asegurándose de que todos los demás jugadores vieran la actualización.

¿Lag?

Cero absoluto.

¿Y las trampas?

¡Bloqueadas!

Cada paso, cada salto, cada golpe era validado, aprobado y transmitido por el servidor.

Jeff se reclinó un momento, asimilando el resultado.

La base ya era sólida.

Los clientes podían actuar, pero solo con permiso.

Ya tenía la build del servidor y la lógica era impecable.

Ahora, era el momento de ponerlo en marcha.

Para las primeras pruebas, lo lanzó desde su propia PC.

una ventana de terminal, un comando, y el mundo arrancó al instante.

Pero no iba a detenerse ahí.

Abrió un navegador, inició sesión en DigitalOcean y puso en marcha un VPS de Linux.

Alquiló un servidor remoto en línea que funciona 24/7.

Esto permite que cualquiera, desde cualquier parte del mundo, se conecte, siempre que tenga la IP.

En cuestión de minutos, subió los archivos del servidor, configuró el reenvío de puertos y aseguró el cortafuegos.

El mundo estaba listo para ser accedido más allá de su máquina local.

El juego ya estaba en línea a nivel mundial.

Así que, añadió un nuevo campo de entrada en el menú principal.

[ Unirse por dirección IP ]
Ahora cualquiera podía conectarse al servidor simplemente escribiendo la IP del anfitrión.

Pero Jeff no se detuvo ahí.

Quería llevarlo un paso más allá.

Abrió el backend y vinculó la IA RAZi para monitorizar todo, como los registros, las métricas del servidor y el comportamiento de los jugadores.

Si ocurría algo sospechoso, RAZi actuaría al instante.

Podía expulsar automáticamente a los tramposos, generar criaturas en zonas de mucho tráfico para mantener las cosas interesantes, activar eventos meteorológicos aleatorios en zonas de baja población para mantener viva la atmósfera e incluso reiniciar el servidor si detectaba fugas de memoria.

Con RAZi integrada, el servidor se convirtió en una entidad dinámica y autogestionada, que respondía a las necesidades de los jugadores en tiempo real mientras Jeff podía centrarse en perfeccionar el juego en sí.

Era un sistema fluido e inteligente que hacía que toda la experiencia funcionara mejor que nunca.

La mayoría de los juegos tenían paneles de administración, pero Jeff tenía una visión diferente: una IA que gestionara el mundo por él.

¿Y la mejor parte?

Funcionaba en silencio, observándolo todo sin ser vista, asegurando que el juego funcionara sin problemas en segundo plano.

Continuando, Jeff abrió el editor de IU de Unity y se quedó mirando el lienzo vacío.

Un juego para un solo jugador estaba bien, ¿pero esto?

Esto era el portal a mundos compartidos.

Arrastró un panel y comenzó a diseñar la interfaz, una que fuera limpia y adaptable.

Cada elemento fue cuidadosamente pensado, asegurando que los jugadores tuvieran una interfaz fluida e intuitiva mientras exploraban este nuevo mundo compartido.

En la parte superior, aparecieron unas letras blancas en negrita.

[Sala Multijugador]
Luego añadió tres botones: Servidor Anfitrión, Unirse al Servidor y Buscar Servidor.

Para el servidor anfitrión, hacer clic en él iniciaría el propio juego del jugador como anfitrión.

Lo conectó a la lógica de arranque del servidor de Mirror e incluso añadió la integración con el portapapeles para que pudiera copiar la IP del jugador automáticamente.

Luego, junto a unirse al servidor, colocó un campo de entrada.

Aquí es donde los jugadores podían pegar la IP de otra persona.

Un botón de conectar estaba a su lado y, con un solo clic, Mirror intentaría unirse a la sesión.

¿Para buscar servidor?

Por ahora, este botón estaba desactivado, un marcador de posición para una funcionalidad futura cuando se implementara el descubrimiento y listado de servidores.

Jeff sonrió ante su progreso, satisfecho con la fluida interfaz que estaba construyendo.

El juego empezaba a tomar forma y pronto estaría listo para que los jugadores se conectaran, exploraran y colaboraran.

Planeaba activarlo más tarde, una vez que construyera una lista de servidores maestros.

Pero el marcador de posición ya estaba allí, listo para mostrar las salas públicas ordenadas por región, número de jugadores y tipo de juego.

Finalmente, Jeff añadió un texto de estado en la parte inferior.

[Esperando conexión…]
Lo probó y, al hacer clic en Servidor Anfitrión, el mundo se cargó.

A continuación, abrió un segundo cliente, escribió 127.0.0.1 e hizo clic en Unirse.

¡Bum!

Ambos jugadores aparecieron en el mismo lugar y funcionó a la perfección.

La conexión era fluida, el mundo estaba en vivo y Jeff no pudo evitar sonreír ante el progreso.

Era oficial, su sistema multijugador ya era totalmente funcional.

Jeff sabía que alojar el mundo era solo la mitad del trabajo.

Ahora venía la parte delicada: asegurarse de que todos vieran lo mismo.

Empezó con los bloques.

Cada vez que un jugador rompía o colocaba un bloque, se aseguró de que la acción activara una función [Command] para enviar la solicitud al servidor.

El servidor entonces validaba la acción y usaba un [ClientRpc] para actualizar a todos los jugadores conectados.

Esto aseguraba que todos vieran los cambios en tiempo real, manteniendo el mundo consistente para todos los jugadores.

Era un sistema simple, pero sería la base de todo lo que vendría después.

A continuación, abordó las ubicaciones y el movimiento de los jugadores.

Añadió un NetworkTransform a cada prefabricado de jugador.

Esto transmitía su posición, rotación y escala a través de la red, garantizando una sincronización fluida de sus movimientos.

Incluso con 10 jugadores corriendo por ahí, el servidor no tenía ni una pizca de lag.

Todo funcionaba con fluidez, sin caídas de rendimiento, lo que garantizaba que la jugabilidad multijugador se sintiera impecable y receptiva.

Al ver esto sonrió, totalmente complacido con lo eficiente que funcionaba el sistema.

Lo siguiente, Inventario y Salud.

Luego creó una clase sincronizada para el inventario de cada jugador usando SyncVar para los objetos, y ganchos incorporados para actualizar la IU cada vez que ocurrían cambios.

Esto aseguraba que el inventario de cada jugador se mantuviera sincronizado en todos los clientes.

También usó NetworkAnimator para sincronizar las animaciones de ataque, los indicadores de daño y las muertes entre los clientes.

Ahora, cuando alguien recibía daño o comía, todos lo veían en tiempo real, creando una experiencia dinámica y conectada para todos los jugadores.

El mundo se sentía vivo, con cada acción siendo compartida y sentida por todos en el juego.

Así que se estiró un momento, sintiendo una repentina oleada de frescura.

Se sorprendió de que, después de un total de 2 horas así como si nada, ni siquiera se sintiera incómodo.

¿Y el estiramiento?

Era solo una costumbre suya.

El código ya estaba listo, el modo multijugador implementado y ahora era el momento de probarlo.

Con eso, ejecutó dos instancias en el mismo portátil, una como servidor sin cabeza y la otra como cliente.

Dos jugadores aparecieron en el mismo mundo.

No hubo tirones ni retardo de entrada, solo un movimiento nítido en tiempo real que se reflejaba impecablemente en ambas ventanas.

Y, literalmente, funcionó sin problemas.

El servidor manejaba todo con precisión, y la jugabilidad se sentía como si dos máquinas separadas estuvieran jugando juntas en perfecta sincronía.

Colocó un bloque en un cliente y apareció al instante en el otro.

Lo rompió y desapareció en ambos mundos en el mismo fotograma exacto.

Los cambios en el inventario, los mensajes de chat e incluso el daño simulado se sincronizaban en perfecta armonía.

Jeff se inclinó, observando cómo los registros del servidor se actualizaban en tiempo real, mientras una sensación de satisfacción lo invadía.

Todo funcionaba como se esperaba, sin ningún tipo de problema.

El sistema multijugador estaba finalmente en vivo y se sentía como si un mundo estuviera cobrando vida de verdad.

Había que entender que, ahora que el modo multijugador estaba completo, no podía ser gratuito para siempre.

No si quería escalarlo, darle soporte y construir una verdadera plataforma a partir de él.

—Era hora de introducir el Paquete Multijugador Premium —declaró.

Con eso, abrió un nuevo script y comenzó a reestructurar la lógica.

Primero, aisló las características principales del modo multijugador, cosas como el alojamiento básico, la unión a partidas y el juego en LAN para grupos pequeños.

Esas permanecerían gratuitas y accesibles para todos.

Luego, añadió un indicador premium.

Un simple archivo de licencia, «premium.key», que si se detectaba, desbloquearía las opciones de alojamiento avanzadas.

Esas opciones eran servidores más grandes, límites de jugadores personalizados, ajuste de rendimiento y, finalmente, soporte para mods y acceso al listado público.

Para hacer cumplir esto, añadió una comprobación de permisos en la rutina de inicio del juego.

Si se detectaba un archivo de licencia premium válido, las herramientas de modding se desbloquearían.

De lo contrario, permanecerían bloqueadas, ocultas tras un mensaje por defecto que simplemente decía:
[Actualiza para acceder a las funciones avanzadas]
…

C#
if (File.Exists(“premium.key”)) { EnableProFeatures(); } else { LockToFreeMode(); }
…

Envolvió todas las herramientas avanzadas en puertas de validación, separando los archivos de configuración de nivel profesional de la instalación estándar.

Ya que más tarde añadiría un menú de Gestor de Mods que solo aparecería si se encontraba la clave de licencia.

Todo se alternaba limpiamente, de modo que incluso los usuarios gratuitos podían unirse a servidores con mods, pero solo los usuarios premium podían crearlos.

Incluso la IU del servidor recibió una actualización: el menú desplegable de «Máx.

de jugadores» tendría un límite de 10 por defecto, a menos que se desbloqueara el premium.

Con eso, decidió probarlo y todo se alternó limpiamente.

Ahora los usuarios gratuitos podían probar una parte de la experiencia.

Sin exploits de duplicación, sin efecto de goma y sin inundaciones de paquetes.

Solo rendimiento puro y optimizado.

Luego activó su sistema de carga de trozos y caminó por diferentes zonas.

Los trozos se cargaban solo cuando era necesario y se eliminaban cuando los jugadores se iban.

El culling aseguraba que los jugadores nunca renderizaran lo que no podían ver, optimizando aún más la experiencia.

Añadió una capa de compresión para los datos de red y, como era un dios pero no el dios, no buscó errores.

Buscó pruebas de que no había ninguno y los resultados fueron absolutamente impecables.

El sistema funcionaba a la perfección y todo operaba como un reloj.

Ahora que todo estaba hecho, y como todavía no tenía un mercado, necesitaba hacer algo por la comunidad.

Viendo los registros del servidor desplazarse como poesía pura.

Con el sistema multijugador ahora impecable.

Sin lag, fallos ni errores.

Con el multijugador como presente, el modding sería el futuro.

Ya que si alguna vez dejaba esto sin actualizar durante mucho tiempo, los jugadores se aburrirían.

Así que, mientras se preparaba para el mercado, dejaría que el jugador del juego anfitrión hiciera los mods él mismo para hacer el juego entretenido.

Por lo tanto, abrió su editor y creó una nueva carpeta dentro del directorio del juego: /Mods
Luego, lanzó a RAZi y le dio una instrucción.

«Escanea los archivos locales en /Mods.

Al iniciar, carga cualquier definición personalizada de bloques, criaturas, texturas o superposiciones de IU».

Con eso, RAZi analizó la estructura al instante, ya que cada vez que tenía tiempo libre, siempre mejoraba a RAZi; se podría decir que esta IA suya era ahora cinco veces mejor que chatgpt.

Luego creó un script cargador de mods.

Gracias a él, escanearía los archivos .json o .dll.

Si seguían el formato correcto, el motor los inyectaría en el mundo del juego.

Definió algunas categorías; para organizar la estructura de los mods, definió tres tipos de archivos principales.

Primero, mod_block.json para añadir nuevos bloques o herramientas; segundo, mod_entity.json para criaturas o PNJ personalizados; y por último, mod_ui.json para rediseños del HUD o modificaciones de la interfaz.

Para demostrar cómo funcionaba, escribió un mod de prueba simple como ejemplo, mostrando lo fácil que era añadir nuevo contenido al juego a través de estos archivos estructurados.

…

json
{ “type”: “block”, “name”: “Obsidiana Brillante”, “texture”: “obsidian_glow.png”, “light_level”: 15, “break_time”: 10 }
…

Cuando volvió a lanzar el juego, allí estaba: la obsidiana brillante.

Totalmente funcional: se podía colocar, romper y, por supuesto, fabricar.

A continuación, añadió la validación del lado del servidor: cualquier bloque o entidad modificada tenía to que estar presente tanto en el anfitrión como en el cliente.

De ese modo, nadie podría hacer trampas generando objetos falsos o criaturas corruptas.

Por último, añadió una nueva pestaña al menú del juego:
[Gestor de Mods] – Cargar, descargar o previsualizar mods activos.

No pudo evitar sonreír, pues ya estaba hecho.

…

¡Agradecimiento especial para ‘Meiwa_Blank👑’ –la CABRA de este mes– por los Boletos Dorados!

¡Te quiero, hermano!

¡Agradecimiento especial para ‘Devon1234👑’ –la CABRA de este mes– por los Regalos!

¡Te quiero, hermano!

Fuente: Webnovel.com, actualizado en Leernovelas.com