egametang/ET
ET
ET is a C# game server framework and distributed actor model runtime designed for large-scale multiplayer environments. It provides a comprehensive toolkit for building distributed game backends, incorporating a multiplayer network transport layer and a specialized suite for game AI and pathfinding.
The framework is distinguished by its use of a distributed actor model to scale processing across multiple threads and servers, utilizing isolated actors for state management and messaging. It features a unified codebase architecture that allows shared logic between the server and client, enabling the development of automated bots for stress testing and quality assurance.
The system covers a broad range of capabilities including multi-protocol network routing with support for TCP, WebSocket, and KCP, as well as zero-garbage collection binary serialization. It includes tools for server-side navigation meshes, visual decision trees, and dynamic library hot-reloading for updating logic without restarting processes.
The framework provides native integration with the Unity3D engine for entity management and runtime inspection.
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.
- Game Server Frameworks - Distributed game server framework for Unity.
- Librerías de redes - Client/Server framework for Unity.
