How endstonemc/endstone works
A continuación se detalla una guía para separar y agrupar las carpetas y componentes del proyecto Endstone según sus funcionalidades principales, lo cual ayudará a construir un diagrama de arquitectura detallado y preciso:
Identificar las áreas principales del proyecto
• Infraestructura y Configuración: incluye archivos y carpetas que se ocupan de la construcción, pruebas, despliegue y documentación.
• Documentación y Recursos: todo el material relacionado con las guías, documentación y tutoriales.
• Núcleo del Motor y API de Plugins: el corazón del proyecto, donde se implementa el sistema de plugins y la lógica principal.
• Integración C++/Python y Capas de Abstracción: separa claramente el código que permite la extensión vía Python y la base de código en C++.
• Plataforma Bedrock y Funcionalidades de Juego: módulos orientados a la gestión de actores, comandos, eventos, red y otros aspectos propios del servidor BDS.
• Pruebas y Validación: conjunto de pruebas unitarias y de integración.
• Dependencias Externas y Terceros: librerías y código externo que se integran al proyecto.
Separar las carpetas según su funcionalidad más relevante
a. Infraestructura y Configuración:
• Archivos radiculares del build y configuración:
• CMakeLists.txt, conanfile.py, pyproject.toml, Dockerfile, docker-compose.yml, .clang-format, .clang-tidy, .dockerignore, .gitignore, etc.
• Automatización y CI/CD:
• Carpeta .github (workflows, templates, dependabot, etc.).
• Scripts de instalación y utilidades:
• Carpeta scripts (autoinstall.sh, start.sh, etc.).
b. Documentación y Recursos:
• Documentación:
• docs/ (incluye guías de inicio, tutoriales, referencias, configuración de estilos y plantillas).
• mkdocs.yml, readthedocs.yaml.
• Otros recursos:
• README.md, CHANGELOG.md, CODE_OF_CONDUCT.md, CONTRIBUTING.md, LICENSE.
c. Núcleo del Motor y API de Plugins:
• Capa en Python (API alta para plugins):
• Carpeta endstone (archivos como __init__.py, actor.py, ban.py, command.py, etc.) que definen la API disponible para los plugins en Python.
• Capa en C++ (interfaz y soporte nativo):
• Carpeta include/endstone (muchos headers organizados por funcionalidad: actor, ban, block, command, event, plugin, etc.).
• Implementación central y lógica:
• Carpeta src/endstone/core (que contiene la lógica central del motor en C++: gestor de comandos, carga de plugins, red, etc.).
• Integración de Plugins nativos:
• src/endstone/plugin, src/endstone/python – se encargan de cargar y gestionar plugins escritos en C++ y Python respectivamente.
d. Plataforma Bedrock y Funcionalidades de Juego:
• Soporte para el servidor Bedrock y funcionalidades específicas de Minecraft:
• Carpeta src/bedrock/ (estructura extensa que incluye módulos para manejar: red (src/bedrock/network), eventos, comandos (src/bedrock/server/commands), gameplayhandlers, niveles (level), recursos, entidades (actor, player), y más).
• Funciones específicas de juego:
• Módulos relacionados con actores, niveles, bloques, inventarios y otros aspectos de la dinámica del juego se encuentran distribuidos en subcarpetas dentro de src/bedrock y en la carpeta endstone (en un estilo más orientado a la API).
e. Pruebas y Validación:
• Tests:
• Carpeta tests/ (contiene pruebas de las funcionalidades del motor, el sistema de plugins, casos específicos en C++ y Python).
f. Dependencias Externas y Terceros:
• Dependencias:
• Carpeta third_party/ (para integraciones y librerías externas), además de los submódulos de git.
Construir el diagrama del sistema
a. Dibuje nodos separados para cada uno de los grupos funcionales definidos:
• Infraestructura / Configuración (conectado a CI/CD y despliegue).
• Documentación y Recursos.
• Núcleo del Motor y API de Plugins (dividir en subnodos para la capa Python, la capa C++ y la integración de plugins).
• Plataforma Bedrock / Funcionalidades de Juego (subdivida en módulos de red, eventos, comandos, gameplay, etc.).
• Pruebas.
• Dependencias Externas.
b. Establezca relaciones y flujos de datos entre estos componentes:
• Conexión entre la infraestructura (scripts, CI/CD, build) y el núcleo del motor.
• Flujos de comunicación entre la API de plugins (Python/C++) y la plataforma Bedrock para invocar comandos, procesar eventos, etc.
• Apunte cómo el sistema de plugins se integra desde capas bajas (C++/Bedrock) y se expone para extensiones en Python.
• Indique que las pruebas actúan sobre el núcleo de la aplicación y la plataforma de juego.
c. Utilice elementos visuales para representar patrones y dependencias:
• Etiquetas claras para cada componente y grupo.
• Flechas direccionales que indiquen dependencias (por ejemplo, del motor central hacia la capa de red y de comandos).
• Recursos o cajas con colores distintos para distinguir capas de abstracción (por ejemplo, capas de API vs. implementación nativa, etc.).
Recomendaciones generales para el diagrama
• Incluir leyendas, etiquetas y claves para identificar claramente cada grupo funcional.
• Mantener el diagrama lo más detallado posible, separando cada carpeta/grupo en nodos específicos para reflejar la organización del código.
• Indique las integraciones externas (PyPI, Docker, etc.) y cómo se despliega el sistema.
Esta separación basada en las funcionalidades extraídas directamente del árbol del proyecto y las indicaciones del README permite al diagrama reflejar de forma muy precisa la arquitectura de Endstone, destacando tanto la plataforma para plugins (en Python y C++) como la infraestructura necesaria para un servidor Bedrock robusto y modular.
Al seguir estas pautas, el diagrama resultante mostrará de forma clara la interconexión entre los componentes estructurales del proyecto y facilitará el entendimiento global para la ingeniería de software del sistema.