egametang/ET

Features

• Game Backend Frameworks - Provides a comprehensive distributed server platform for real-time multiplayer games including network routing and service discovery.
• Distributed Actor Frameworks - Implements a distributed actor model to scale state management and asynchronous messaging across a multi-process cluster.
• Binary Data Formats - Uses BSON-based binary serialization to minimize garbage collection and optimize network throughput.
• Actor Messaging - Enables isolated execution units to exchange data via a dedicated messaging mechanism to coordinate distributed tasks.
• Data Serialization Formats - Uses BSON for messages and configuration files to ensure compatibility with document-based storage.
• High-Performance Binary Serialization - Implements a binary serialization format designed for high performance and zero garbage collection.
• Hot Code Reloading - Allows updating application logic and configurations in real-time without restarting active processes.
• Zero-Downtime Binaries Upgrades - Injects dynamic libraries into a component design to enable server-side updates without causing downtime.
• Distributed Game Backends - Implements a scalable component architecture that can function as a single cluster or across multiple processes.
• Entity - Manages game entities as isolated actors to process concurrent state updates and messaging.
• Runtime Code Injection - Dynamically loads and executes updated code modules to apply changes without restarting the application.
• Network Transport Layers - Implements a robust communication system supporting TCP, WebSocket, and KCP for multiplayer data transfer.
• High-Performance Messaging Infrastructures - Processes hundreds of thousands of concurrent messages per second using high-performance messaging infrastructure.
• Message Routing - Routes messages to entities using unique identifiers to communicate across servers without requiring physical host locations.
• Multi-Protocol Routing - Features a software router that switches between TCP, UDP, and WebSockets to optimize connectivity.
• Game State Synchronization - Implements frame synchronization with prediction and rollback to keep multiplayer clients aligned.
• Fiber-Based Schedulers - Uses lightweight fibers for concurrent execution to maximize multi-core hardware utilization.
• Actor-Based Concurrency - Uses an actor-based runtime to handle isolated state and concurrent processing for game entities.
• Distributed Coordination Systems - Coordinates server logic and client communication to support large-scale online multiplayer environments.
• Isomorphic Logic Sharing - Utilizes a shared codebase for both clients and bots to ensure logic consistency and facilitate testing.
• Dynamic Zone Scaling - Manages dynamic instances and zone splitting to allocate resources based on current player demand.
• Unified Language Synchronization - Ensures network messages and configurations remain synchronized through a unified language and shared code references.
• Unified Codebase Architectures - Uses a single codebase for both frontend and backend to reduce duplication and accelerate development.
• Multiplayer Synchronization - Manages real-time game state across clients and servers using KCP, TCP, and WebSocket protocols with prediction and rollback.
• Behavior Trees - Provides visual editors for behavior trees to define complex quest flows and skill triggers.
• Declarative AI Programming - Uses a declarative process to define complex entity behaviors and artificial intelligence logic.
• Game World Pathfinding - Performs server-side navigation and pathfinding using a native language implementation of industry-standard navigation meshes.
• Area of Interest Filtering - Reduces network traffic and processing load by filtering entity visibility using a spatial grid.
• Runtime Logic Hot-Updates - Allows updating protocols and configurations on the client by switching runtime environments without a reinstall.
• Gameplay Verification - Provides automated compilation and multi-bot testing to validate that gameplay code changes function correctly.
• Cloud Native Infrastructure - Deploys cloud-native architectures that support multi-process scaling, observability, and hotfix workflows.
• Area of Interest Filtering - Filters visible players using a grid-based area of interest system to reduce server processing load.
• Game AI and Pathfinding Toolkits - Ships a specialized suite for server-side navigation meshes, decision trees, and automated bot simulation.
• Game Automation Bots - Provides tools to create automated gameplay bots by sharing logic between the client and server.
• Unity3D Integrations - Provides native integration with the Unity3D engine for entity management and shared C# logic.
• Game Engines & Frameworks - Connects a C# server framework to the Unity engine for entity management, runtime inspection, and shared logic.
• Seamless World Implementations - Implements seamless transitions between scenes to create a continuous and large-scale environment.
• Server-Side Pathfinding - Implements server-side pathfinding and movement calculations using navigation data exported from 3D scene editors.
• Adaptive Transport Switching - The product toggles between TCP, WebSocket, and reliable UDP to optimize for specific network conditions and packet loss.
• Service Discovery Mechanisms - Registers and queries services across multiple processes using heartbeats and automatic failover.
• Network Protocol Testing - Validates network protocol logic within a complete environment without mocking external interfaces.
• Network Transport Protocols - Utilizes KCP with TCP, UDP, and WebSocket fallbacks to maintain stable, high-performance network connections.
• Asynchronous Programming Patterns - Supports writing asynchronous logic in linear sequences using async and await patterns.
• Multi-Process Parallelism - Runs high-demand operations on separate fibers using a multi-process architecture to leverage multi-core hardware.
• Distributed Orchestration Platforms - Manages process lifecycles and observability for distributed clusters using external orchestration tools.
• Dynamic Room Scaling - Implements a distributed actor model with dynamic room scaling to support large-scale games.
• User Interaction Simulation - Creates bot instances that mirror real player actions to perform load and stress testing.
• QA Bot Frameworks - Uses shared logic layers between the client and server to build automated bots for quality assurance.
• Environment Simulations - Implements automated tests that mirror client-server interactions using robotic clients to validate logic and interfaces.
• Integrated Logic Testing - Executes tests within a complete environment using actual logic code to eliminate the need for mock objects.
• Game Bot Stress Testing - Creates and runs robotic clients and AI bots to simulate user behavior and validate server performance.

Star history