awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
space-wizards avatar

space-wizards/space-station-14

0
View on GitHub↗

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
spacestation14.com
↗

Space Station 14

Space Station 14 is a C# multiplayer game and roleplay simulation framework. It is built upon an Entity-Component-System (ECS) game engine that separates logic into systems and data into components to manage complex entity interactions. The project functions as a grid-based physics simulator with a YAML data-driven prototype system for defining game objects.

The project features a specialized 2D sprite rendering engine that maps server-side appearance data to client-side shaders. It implements a networking model with client-side prediction and dirty-flagged state synchronization to reduce input lag and bandwidth. The simulation is distinguished by its deep environmental systems, including atmospheric gas dynamics and electrical grid solving.

The capability surface covers procedural world generation, complex character physiology, and detailed biological and chemical simulations. It includes extensive administrative tooling through an in-game console, as well as comprehensive server hosting and lifecycle management utilities. The interface is managed via a bound UI system supporting XAML definitions and custom stylesheets.

Features

  • Entity Component Systems - Built upon an Entity-Component-System architecture to decouple game behavior from raw data for high-performance simulation.
  • Game Development Engines - Built upon a custom Entity-Component-System engine to decouple game data from behavior for complex simulations.
  • Multiplayer Networking - C# multiplayer simulation featuring networked physics, synchronized entity states, and client-side prediction.
  • Delta Synchronization - Optimizes network bandwidth by using dirty flags to synchronize only the modified fields of entity components.
3,523 stars·5,058 forks·C#·mit·22 views
  • Entity Component Assignment - Implements core ECS functionality for attaching and modifying functional components on entities to change their behaviors.
  • Entity Exclusion Filters - Narrows down entity lists based on component presence, prototypes, and spatial proximity.
  • Custom Command Definitions - Allows the definition of executable console commands via C# classes and methods with customizable arguments.
  • Visual Asset Synchronization - Updates client-side visual representations of objects based on appearance data sent from the server.
  • Live Script Execution - Implements a C# REPL that allows developers to test and execute logic on the live server and client without restarting.
  • Game Asset Synchronization - Streams uploaded resources and game prototypes from the server to the client to ensure content consistency.
  • 2D Coordinate Systems - Uses a right-handed 2D coordinate system with metric measurements to position entities within the world.
  • 2D Rigid Body Physics Engines - Calculates real-time movement and collisions for 2D objects using a multithreaded physics engine with mass and inertia.
  • Atmospheric Gas Simulations - Implements systems to filter and recycle air to maintain life support and resource stability.
  • Atmospheric Life Support Systems - Monitors air quality and dispenses air from recyclers to maintain habitable conditions.
  • Biological Combat Mechanics - Provides biological combat abilities including armblades and sonic shrieks for fighting crew members.
  • Character Definitions - Defines character entities with unique physical attributes, including modified hitboxes and movement speeds.
  • Chemical Synthesis Systems - Transforms raw elements into medicinal items or toxins using lab machines and chemical recipes.
  • Client-Side Prediction Systems - Implements client-side prediction to simulate game logic locally, eliminating perceived input lag in multiplayer interactions.
  • Data-Driven Item Definitions - Employs YAML-based prototypes to define game objects and components, enabling content creation without modifying source code.
  • Data-Driven Visual Configurations - Defines sprite layer properties including textures and shaders using external configuration files.
  • Component Validation - Validates the existence and ownership of required components for an entity before executing corresponding system logic.
  • Dynamic Component Modification - Adds or removes components on an entity at runtime to change its behavior or state.
  • Entity Definitions - Implements data-driven definitions of game objects and their components using a structured YAML format.
  • Playable Mob Definitions - Defines playable entities by inheriting base organic mob properties and linking to species appearance.
  • Runtime Modifications - Allows the runtime modification of entity variables and data paths to change object states dynamically.
  • Entity Queries - Implements high-performance ECS filtering to retrieve entities based on components, names, or spatial proximity.
  • Structural Failure Simulations - Triggers structural failures like bursting pipes when atmospheric limits are exceeded.
  • Game Asset Management - Provides a central manager to index and retrieve game object definitions using unique identifiers.
  • Game Content Extension - Implements a system for creating new game objects and components using C# and YAML configurations.
  • Game Entity Identifier Mappings - Translates internal entity IDs into network-safe identifiers for consistent referencing between server and client.
  • State Debugging Tools - Provides specialized runtime tools for inspecting internal game logic and troubleshooting entity states.
  • Object Spawning - Allows developers to instantiate entities and tiles instantly into the game world via a dedicated UI.
  • Grid-Based Physics Simulations - Simulates rigid body dynamics and atmospheric gas flow across a chunked tilemap.
  • In-Game Administrative Consoles - Implements an in-game console for executing shell-like commands to perform administrative tasks and view system logs.
  • In-Game Power Grid Simulation - Deploys voltage wiring to connect generators and storage to area power controllers.
  • In-Game Resource Networks - Creates systems of connected points on entities to facilitate the flow of resources.
  • Interaction Verb Systems - Implements foundational systems for user actions, including command verbs and delayed tasks.
  • Objective-Based Role Assignment - Assigns players roles with distinct objectives, ranging from solitary actors to coordinated teams.
  • Game Servers - Provides infrastructure for hosting multiplayer servers, managing builds, and moderating players.
  • Role-Play Gameplay Mechanics - Implements complex social systems and antagonistic objectives central to the roleplay simulation.
  • Roleplay Simulation Frameworks - Manages complex character archetypes, social loyalty metrics, and emergent objective-based gameplay.
  • Simulation Worlds - Simulates complex, procedurally generated environments featuring grid-based maps and atmospheric gas dynamics.
  • Threat Engagement Systems - Implements systems for neutralizing disruptive threats using specialized equipment and player cooperation.
  • Chunked Tilemap Storage - Manages large-scale game worlds using a chunked hashmap system for efficient tilemap storage and updates.
  • Static Sprite Renderers - Provides a layered graphics system that maps server-side appearance data to client-side shaders and sprite sheets.
  • Composite Sprite Generation - Builds a final entity sprite by aggregating visual data from multiple internal sub-entities.
  • Layered Sprite Rendering - Displays textures and sprite sheets using a layered system with shaders and draw-depth ordering.
  • Appearance Data Mappings - Updates entity appearance by mapping server-sent data to sprite layers, colors, and visibility settings.
  • Sprite Sheet Mapping - Organizes image assets and metadata to map game states to coordinates on 2D spritesheets.
  • Client-Server Clock Synchronization - Aligns the client's local clock with the server's base time to ensure consistent event timing.
  • Game Event Pub-Sub Systems - Uses a pub-sub mechanism to send notifications to all subscribed systems to coordinate global state.
  • Network Event Emission - Facilitates real-time, bidirectional event-based communication between clients and servers independently of entity state.
  • Multiplayer Connection Handshaking - Coordinates authentication, encryption key exchange, and string table synchronization during the initial connection process.
  • Game State Synchronization - Synchronizes game state between server and client using client-side prediction and delta updates to minimize lag.
  • World Chunking - Uses a chunked hashmap system to efficiently store and update large-scale world grids, supporting dynamic expansion.
  • Object Prototypes - Utilizes a YAML-driven pipeline to define game object prototypes and their behaviors.
  • Administrative Privilege Management - Provides a comprehensive system for managing high-level administrator permissions and super-user roles.
  • Command Access Control Policies - Controls the execution of specific console commands by assigning permission attributes to users.
  • Role-Based Access Control - Implements a role-based access control system to define permissions for visitors and permanent crew.
  • User Access Moderation - Provides administrative tools to kick or ban players using tracked hardware IDs and IP addresses.
  • Game State Replication - Synchronizes game entity data from server to clients using state objects triggered by dirty flags.
  • ECS Component Lifecycles - Executes logic automatically when components are added, initialized, or removed from an entity.
  • ECS System Definitions - Implements ECS logic using query-callback pairs where systems listen for events and operate on matching components.
  • Entity-Directed Event Routing - Triggers callbacks on specific entities to notify systems interested in that entity's state.
  • Event-Driven Coordination - Coordinates interactions between decoupled entities and systems using high-performance, struct-based event dispatching.
  • Headless Logic Decoupling - Implements an architectural separation of server-side game state and business logic from the client-side visual rendering layers.
  • High-Performance Event Dispatching - Triggers logic via struct-based events raised by reference for high performance and serialization.
  • Dependency Injection - Utilizes dependency injection to provide required entity systems to other systems via attributes, decoupling system resolution.
  • Programmatic Entity Manipulation - Modifies or deletes world objects by filtering for names, prototypes, or components via administrative tools.
  • Logic Decoupling - Separates game behavior into decoupled systems that operate exclusively on raw data components within an ECS architecture.
  • Game Server Managers - Utilizes a watchdog wrapper to automate server updates, monitoring, and restarts.
  • Species Visual Customization - Specifies visual traits and body components that determine how a species looks and behaves.
  • Entity Composition Systems - Implements an entity composition system that builds complex logical entities from modular sub-entities with independent behaviors.
  • Network State Delta Updates - Reduces network bandwidth by transmitting only modified fields of entity components between server and client.
  • In-Game User Interfaces - Links UI windows to game entities, synchronizing interface state with backend component data.
  • View-to-Data Mappings - Links server-side appearance data entries to client-side sprite layer properties through generic configuration.
  • Input Prediction - Implements client-side logic simulation to eliminate perceived input lag while waiting for server confirmation.
  • Game Server Hosting - Configures the backend environment and hosting resources required for multiplayer game servers.
  • Hierarchical Task Networks - Uses Hierarchical Task Networks to decompose high-level NPC goals into sequences of primitive tasks.
  • Grid Pathfinding - Utilizes A* and Breadth-First Search algorithms to determine optimal routes across grid-based game world graphs.
  • Multi-Cellular Organism Modeling - Creates biological body parts by defining organ types and associating them with metabolism components.
  • Hierarchical Task Networks - Uses Hierarchical Task Networks to manage complex NPC behaviors by breaking high-level goals into executable primitive tasks.
  • Crash Monitoring - Analyzes core dumps and managed stack traces to identify and debug server crashes.
  • Orthographic Camera Setups - Manipulates the view matrix to handle translation, rotation, and scaling of the orthographic projection.
  • Grid-Based Inventory Layouts - Organizes items in storage using geometric shapes to determine if objects fit within a grid.
  • Loyalty Buffers - Equips characters with a mindshield buffer that absorbs loyalty damage.
  • Game Localization Systems - Implements a framework for translating game interface elements and item descriptions to support global audiences.
  • User Data Storage - Maintains mutable user data in dedicated local directories to preserve state across game restarts.
  • State Snapshots - Captures portable records of node statuses and durability for inspection and analysis.
  • Custom Serialization Interfaces - Implements specialized interfaces to override the reading, writing, and validation of types during serialization.
  • Cargo and Passenger Logistics - Manages the distribution of equipment and materials to different departments within the game economy.
  • Content Hash Verification - Optimizes client updates by downloading only missing file blobs using a server-provided manifest of hashes.
  • Research Value Calculators - Determines numerical research value based on node depth, completeness, and degradation penalties.
  • Result Ordering and Limiting - Extracts specific subsets of data by limiting the result count or randomly sampling values from a set.
  • Game Server Settings - Adjusts server behavior, tickrates, and authentication modes via TOML configuration files.
  • SQLite or PostgreSQL Storage - Supports interchangeable data persistence using either SQLite for local storage or PostgreSQL for remote servers.
  • Type-Specified Arguments - Allows specifying a type as a command argument to determine the resulting output format or parsing logic.
  • System Variable Referencing - Accesses special system variables to identify the current player entity or retrieve pending command output.
  • Nested Command Structures - Supports executing sequences of commands within curly braces to override order of operations or pass computed values.
  • Command Grouping - Organizes multiple command implementations under a single parent command using named sub-commands.
  • Command Argument Parsers - Converts in-game console input strings into specific C# types using built-in and custom type parsers.
  • Variable Output Capture - Saves the results of commands to named variables for reuse in subsequent administrative operations.
  • Command Pipelines - Implements a command-line interface that allows chaining administrative operations via data piping.
  • Command Piping - Implements the ability to pass output from one console command as input to another to chain administrative operations.
  • Availability Controllers - Controls command availability by grouping them into specific operational environments.
  • Console Command Iterators - Iterates through objects and runs specified command blocks for each item based on its properties.
  • Console Data Analysis Tools - Calculates counts and bins unique occurrences to summarize data sets directly via the game console.
  • Command Execution Contexts - Provides a secure execution environment that manages variable access and permission checks for administrative commands.
  • Session State Persistence - Maintains persistent variables and invocation contexts that survive across different user sessions.
  • Command Scripting - Provides a scripting interface to execute sequences of administrative and development commands to manipulate game objects.
  • Entity Teleportation Systems - Implements systems for teleporting entities to specific coordinates or other entities.
  • Dynamic Spawn Logic - Produces items at specific locations based on player population to maintain content flow.
  • String Localization - Uses unique kebab-case identifiers to retrieve and manage localized player-facing strings.
  • Runtime Variable Manipulation - Provides a console-based inspector tool to read, write, and invoke methods on object variables during runtime.
  • Conditional Compilation - Uses preprocessor directives to include or exclude code blocks based on the build target or platform.
  • Game Server Update Automation - Automates server software updates using manifests and integration with Git or CI tools.
  • Remote Build Distribution - Configures download URLs to allow the launcher to automatically fetch and update the client binary.
  • Server Lifecycles - Manages the server lifecycle by sending remote commands for graceful shutdowns and scheduled restarts.
  • Chemical Threshold Triggers - Restricts the activation of chemical effects based on criteria such as gas concentration thresholds.
  • Grid-Based - Implements A*-based navigation on coordinate grids, accounting for dynamic environmental changes and entity-specific traversal constraints.
  • Administrative Player Communication - Sends private administrative messages to users and manages a real-time help request system.
  • Complex Item Crafting - Produces unique effects or cures by combining precursors sourced from different departments.
  • Biological Research Mechanics - Analyzes mutant remains through autopsies to generate research points based on genetic rarity.
  • Biological Sample Collection - Extracts biopsy samples from living creatures to build a database of genetic material.
  • Character Form Transformations - Enables characters to shift between a disguised humanoid appearance and a distinct combat form.
  • Physiological State Transitions - Triggers a fake death state to facilitate wound recovery and character revival.
  • Biological Effects - Triggers biological or physical changes in characters based on chemical consumption and probability.
  • Substance Definitions - Defines chemical substances with unique identities and thermal thresholds for mixing.
  • Client-Side UI Prediction - Updates UI elements directly from networked data on the client and sends predicted messages for input.
  • Collective Mind Simulations - Implements a hivemind system that integrates devoured minds into a collective for issuing orders.
  • Content Gating Mechanisms - Gates the ability to build advanced equipment behind a research system and specific tier requirements.
  • Coordinated Faction Communication - Provides restricted communication channels for secret coordination among allied character types.
  • Crafting Recipe Definitions - Defines crafting recipes that link required materials and assembly graphs to a final produced item state.
  • Creature Need Simulations - Maintains food, temperature, and pressure levels to ensure the stability of captive mutants.
  • Loyalty and Alignment Systems - Transitions players to antagonists by lowering loyalty health through social interactions and codewords.
  • Behavioral Directives - Defines modifiable directives that govern player behavior through additions or removals.
  • Destructible Terrain - Allows entities to deal structural damage to walls and doors to bypass obstacles.
  • Organic Resource Generation - Produces materials and chemicals through the simulated growth and decay of organic life.
  • Dynamic Event Orchestration - Triggers dynamic game events based on station metrics to maintain a target level of chaos.
  • Dynamic Health States - Transforms a character into a durable endoskeleton after sustaining critical damage.
  • Dynamic Map Geometry Modification - Replaces structural elements like walls with other object types to change accessibility.
  • Dynamic Navigation Meshes - Regenerates navigation meshes at runtime to ensure AI pathfinding accurately reflects environmental changes and spawned entities.
  • Electrical Energy Storage - Implements devices that store electrical energy to maintain consistent service and prevent brownouts.
  • Electrical Throughput Capping - Caps the electricity passing through substations to isolate high-demand machinery and prevent grid failure.
  • World State Snapshots - Captures the physical layout and chaos level of a game session as a database blob for persistence.
  • Collision Optimization - Optimizes simulation speed by toggling collision states based on whether a body is asleep.
  • Destruction Triggers - Implements configurable thresholds that trigger specific actions, such as spawning debris, when an entity is destroyed.
  • Biological Reaction Logic - Controls biological entity reactions to chemicals by linking specific effects to organ markers.
  • Entity Prototype Replacement - Deletes entities or replaces them with different prototypes while preserving their world position.
  • Entity Spawning Systems - Provides systems for instantiating game objects from prototypes in real-time via code or administrative panels.
  • Predicted Spawning - The game creates temporary client-side entities that are replaced by authoritative server entities.
  • Hazard Immunities - Provides immunity to poison, radiation, and vacuum by increasing character resource consumption.
  • Equipment Slot Definitions - Defines dedicated equipment slots for armor and breathing apparatus to provide environmental protection.
  • Antagonist Role Systems - Creates specialized antagonist roles with unique laws and victory conditions to drive gameplay conflict.
  • Fluid Container Systems - Defines containers on entities to store and manage varying quantities of chemical reagents.
  • Gameplay Ability System Implementations - Implements a variety of active abilities, including projectile and area-of-effect spells.
  • Game Internal State Visualizers - Visualizes networking, rendering, and entity data via an on-screen overlay and UI tree view.
  • Game Mode Variety - Implements a territory control mode where players compete to claim areas by painting doors.
  • Gameplay Chaos Metrics - Quantifies disorder and player success by tracking chaos metrics across different station departments.
  • Gameplay Moderation - Monitors player behavior and applies consequences to protect the roleplay experience.
  • Genetic Blueprinting - Combines cell samples into complex sequences to create blueprints for new organisms.
  • Identity Mimicry Mechanics - Allows characters to change appearance and vocal patterns to mimic others for infiltration.
  • Identity Spoofing Mechanics - Allows characters to modify their fingerprints to match victims and bypass forensic checks.
  • In-Game Encyclopedia Management - Builds interactive guidebook entries using XML and YAML to provide in-game information to players.
  • In-Game Medical Systems - Implements dynamic medical treatment where cure complexity scales with the severity of diverse wounds.
  • In-Game Signal Routing - Provides a system to attach signal transmitters and receivers to objects via wire panels for remote control.
  • Injury Progression Simulations - Simulates the deterioration of untreated injuries, where neglected wounds can lead to death.
  • Interactive Wildlife - Populates the environment with critters that forage and drop loot to drive emergent player interaction.
  • Local Space Transformations - Assigns local coordinate systems to objects to define relative directions regardless of the entity's world orientation.
  • Localized Network Scoping - Limits message transmission and reception to devices belonging to the same station.
  • Loyalty and Alignment Systems - Restores loyalty health through physical restraint or tools to revert antagonists back to crew members.
  • Match Lifecycle Management - Manages the start, end, and restart of game rounds and toggles operational settings like OOC chat.
  • Medical Diagnosis Simulation - Collects medical data through communication and scanners to determine the correct treatment.
  • Melee Combat Systems - Executes bites and lunging dashes to damage targets or drag them across the environment.
  • Multi-Grid Coordinate Systems - Assigns multiple grids to a single station to support complex layouts like escape shuttles.
  • Narrative Sandboxes - Sequences game phases into story beats with specific chaos goals to manage narrative pacing.
  • Action Constraint Systems - Governs character actions through a prioritized set of rules modified by events or players.
  • Object Appearance Modifiers - Modifies character vocal patterns and appearance to deceive other players during roleplay.
  • Server Discovery Hubs - Polls designated server hubs to list active game servers and filters them by game identifier.
  • Physical Object Interaction - Provides the ability to drag bodies and other humanoids to move them across the map.
  • Physics World Debugging Tools - Visualizes physics rays and bounding boxes to verify collision shapes and interaction logic.
  • Biological Trauma Simulations - Models physical trauma based on damage type and location, triggering effects like organ failure.
  • Planetary Environment Simulation - Applies gravity and breathable atmosphere defaults to maps to simulate planet surfaces.
  • Player Conversion Mechanics - Implements a progression system where entities gain power by converting other players to their side.
  • Player Role Assignment - Provides mechanisms to grant users control over non-player objects by dynamically assigning movement and state components.
  • Objective Assignments - Assigns impactful secret goals to specific players to drive round progression and conflict.
  • Role-Based Objectives - Assigns players benign tasks, such as visiting locations, to encourage roleplay.
  • Power Deficit Simulation - Triggers specific machine behaviors, such as reduced motor speed, in response to electrical power deficits.
  • Power-Domain Communication Restrictions - Ensures devices can only exchange messages if they draw power from the same power source.
  • Power-Gated Game Systems - Blocks devices from receiving network packets if they do not have an active power supply.
  • Power Load Prioritization - Distributes electrical power and automatically disables low-priority loads based on current battery levels.
  • Power Supply Ramp-Up - Simulates the time required for power supplies to increase their output to match new electrical loads.
  • Predicted Audio-Visual Effects - The game plays sounds and popups once for the initiating client while networking them to others.
  • Proximity-Based State Synchronization - Reduces network bandwidth by restricting entity state updates to clients within a specific chunk range.
  • Random Number Generator Seeding - Generates identical random results on client and server using a shared seed based on entity IDs.
  • Resource Refining - Uses electrolysis and centrifugation to refine raw resources into usable chemical precursors.
  • Autonomous AI Agent Simulations - Simulates a self-sustaining ecosystem of plants, fungi, and animals that evolve autonomously.
  • Social Influence Mechanics - Uses a tiered system of codewords in communications to reduce target loyalty for conversion.
  • Spatial Communication Limits - Limits wireless message delivery to devices within a specific distance of the sender.
  • Stealth Administration Systems - Implements a hidden stinger for injecting targets with chemicals to cause hallucinations or mute speech.
  • Stealth Mechanics - Provides mechanics for stealth, invisibility, and teleportation to bypass in-game security and enter locked locations.
  • Steering Behaviors - Calculates movement directions using interest and danger arrays to steer agents away from environmental collisions.
  • Sub-Component Event Routing - Relays events from parent entities to sub-entities to allow independent logic processing within complex entity compositions.
  • Summoned Minion Systems - Allows players to create and control biological minions for scouting and stunning enemies.
  • Synthetic Organism Simulation - Develops mutants by injecting subjects with fused samples and maintaining them in nutrient vats.
  • Metabolic Simulations - Simulates the metabolic breakdown of chemical reagents through specialized biological organs.
  • Dynamic Attribute Scaling - Adjusts entity attributes like speed and power based on damage taken or distance.
  • Technology Tree Systems - Implements a directed acyclic graph where users unlock new capabilities by providing required stimuli.
  • Procedural Generation - Procedurally populates the game world with randomized clusters of hostile fauna and flora.
  • Victory Condition Evaluators - Evaluates conversion percentages and leader survival to determine the victory tier for a game round.
  • Victory Condition Systems - Defines quantitative thresholds for faction success based on player conversion ratios to determine round winners.
  • World Event Triggers - Implements bulk action execution for creating large-scale environmental effects like explosions or group status applications.
  • Field of View Occlusion - Determines visible areas by projecting depth from the camera to the nearest occluders.
  • Dynamic Lighting Integrations - Draws light sources and shadows into an HDR buffer to simulate dynamic lighting and shadow occlusion.
  • Screen Effect Overlays - Applies viewport-wide graphical effects and distortions using GPU shaders as global visual layers.
  • Art Grid Mapping - Implements tools for placing tiles and entities using snap grids and coordinate-based drawing.
  • Entity Synchronization Restrictions - Limits entity synchronization to specific ranges or users to reduce network bandwidth.
  • Game Server Performance Tuning - Optimizes server-side execution speed using dynamic PGO and AVX hardware acceleration to improve performance.
  • In-Simulation Network Messaging - Sends data packets between entities using specific network addresses, supporting both direct targeting and broadcasting.
  • Messaging Channel Management - Creates and manages communication channels for users based on manual subscriptions or departmental assignments.
  • Network Broadcast Filtering - Modifies or cancels a broadcast's recipient list before packets are dispatched to the network.
  • Text Message Transmission - Transmits text messages between specific users via handheld devices using unique identifiers.
  • Traffic Filters - Uses potentially visible sets to filter and restrict network traffic of entity data sent to clients.
  • Archive Media Loading - Loads game assets from compressed archives to allow the client to run without a remote server connection.
  • Implicit Type Casting - Automatically converts data types to compatible forms during the execution of console commands.
  • Contextual Permissions - Assigns security permissions to roles that only become active when a specific job is spawned.
  • Detection Evasion - Implements stealth mechanics like mindshields to evade security scanners and maintain disguises.
  • Action Interception Patterns - Raises attempt events that other systems can intercept to block an action from occurring.
  • YAML Serializers - Implements a YAML deserialization system that supports instance providers to reuse existing objects.
  • Environment Variable-Based Configuration - Sets application parameters using TOML files, command line arguments, and environment variables.
  • Collection Transformations - Evaluates command blocks repeatedly for each item in a sequence to transform data within the admin console.
  • Interactive Logic Linking - Allows linking interactive inputs like buttons and levers to functional entities like blast doors.
  • Delta Update Generation - Delivers only modified files to game clients during updates to reduce download sizes via delta encoding.
  • Configuration Variables - Implements constants and CVars for runtime configuration to improve system maintainability.
  • Strongly-Typed Validators - Validates console command arguments against C# types to ensure data consistency during administrative execution.
  • ECS Component Access Control - Limits which entity systems can read or modify component data using specialized access attributes.
  • Blackboard State Management - Implements a shared blackboard system for NPC state management, allowing AI planners to read and write agent-specific data.
  • Piped Type Inference - Handles arbitrary piped input types using generic methods that infer types from the input stream.
  • Inversion-of-Control Containers - Uses an inversion-of-control container to map interfaces to concrete implementations, decoupling components for easier testing.
  • Modular Stylesheet Architectures - Distributes style rules across modular sheetlets to prevent monolithic configuration files.
  • Mutable State Event Propagation - Passes mutable state through events to allow multiple systems to modify data during a process.
  • UI State Triggers - Triggers specific UI logic automatically when the application enters or exits defined game states.
  • Game Server Administration Interfaces - Provides administrative interfaces and consoles for moderating gameplay and enforcing server policies.
  • Pipeline Inspection - Provides a debugger to deconstruct command runs and visualize the transformation of data types through a pipeline.
  • Server Management Dashboards - Ships a browser-based dashboard for managing player information, bans, and administrator records.
  • XAML - Defines complex UI control trees using XAML XML declarations.
  • Color Palette Systems - Employs a structured palette system with named roles to maintain visual consistency across the UI.
  • Common UI Element Styling - Applies visual rules to UI elements using selectors based on type, class, or identifiers.
  • Element Positioning - Positions interface components using a left-handed coordinate system starting from the top-left.
  • Role-Based Equipment Distribution - Equips characters with branded gear and consumables based on their assigned game roles.
  • Game Information Interfaces - Displays critical game-state information and persistent data panels on the user interface.
  • Multilingual Text Management - Decouples human-readable strings from source code using external files for multilingual translations.
  • Navigation Graph Portals - Creates portals that link separate navigation graphs, enabling AI agents to pathfind across distinct world boundaries.
  • UI Styling - Creates reusable style classes and property assignments within modular stylesheets.
  • UI Window Templates - Builds interactive application windows using pre-defined visual templates.
  • Predicted Entity Deletion - The game hides entities from the client immediately upon a deletion request before server confirmation.
  • Responsiveness Monitoring - Automatically restarts the server process when the system detects a lack of responsiveness.
  • Game Asset Delivery - Delivers game files and assets directly from the server to the launcher using delta updates.
  • Game Engine Remakes - Revived remake of Space Station 13.
  • Role Playing Games - Open-source remake of a multiplayer sci-fi role-playing game.

    • Star history

    Star history chart for space-wizards/space-station-14Star history chart for space-wizards/space-station-14

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does space-wizards/space-station-14 do?

    Space Station 14 is a C# multiplayer game and roleplay simulation framework. It is built upon an Entity-Component-System (ECS) game engine that separates logic into systems and data into components to manage complex entity interactions. The project functions as a grid-based physics simulator with a YAML data-driven prototype system for defining game objects.

    What are the main features of space-wizards/space-station-14?

    The main features of space-wizards/space-station-14 are: Entity Component Systems, Game Development Engines, Multiplayer Networking, Delta Synchronization, Entity Component Assignment, Entity Exclusion Filters, Custom Command Definitions, Visual Asset Synchronization.

    Which projects share features with space-wizards/space-station-14?

    Projects with overlapping indexed features include: sandermertens/flecs — Flecs is a high-performance entity component system framework and data-oriented programming library. It serves as a… isadorasophia/murder — Murder is an entity component system game engine designed for 2D game development. It provides a core framework for… unity-technologies/entitycomponentsystemsamples — This repository is a collection of reference implementations and sample projects demonstrating data-oriented design… tmodloader/tmodloader — tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It… amethyst/amethyst — Amethyst is a data-driven game engine written in Rust for building high-performance 2D and 3D games. It is built on an… veloren/veloren — Veloren is an open-source multiplayer RPG featuring a voxel-based action adventure in a procedurally generated fantasy…

    Projects sharing features with Space Station 14

    These projects share indexed features with Space Station 14. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • sandermertens/flecsSanderMertens avatar

      SanderMertens/flecs

      8,045View on GitHub↗

      Flecs is a high-performance entity component system framework and data-oriented programming library. It serves as a simulation engine core and game engine architecture tool, decoupling state from behavior by separating entities, components, and systems. The framework features a runtime reflection layer for dynamic data inspection and a built-in scripting system for defining entity behavior without recompilation. It also includes a network interface and REST API for remote simulation administration and state querying. The library covers a broad surface of simulation capabilities, including ar

      Cc99cpp11cpp14
      View on GitHub↗8,045
    • isadorasophia/murderisadorasophia avatar

      isadorasophia/murder

      3,171View on GitHub↗

      Murder is an entity component system game engine designed for 2D game development. It provides a core framework for managing game objects through an ECS architecture and includes a dedicated 2D game editor for asset management and real-time property configuration. The engine features a specialized 2D rendering pipeline supporting pixel art, sprite slicing, and parallax effects. It includes a hierarchical A* pathfinding system for agent navigation and a comprehensive asset management system for serializing and loading game resources. The project covers a broad range of capabilities, including

      C#fnagame-enginegamedev
      View on GitHub↗3,171
    • unity-technologies/entitycomponentsystemsamplesUnity-Technologies avatar

      Unity-Technologies/EntityComponentSystemSamples

      8,127View on GitHub↗

      This repository is a collection of reference implementations and sample projects demonstrating data-oriented design using the Unity Entities package. It provides a suite of examples for implementing an entity component system that separates game data into components and logic into systems. The collection includes specialized demonstrations for rendering large volumes of entities via graphics pipelines, implementing high-performance collision and rigid body dynamics through data-oriented physics, and managing multiplayer state synchronization using the network framework for entities. It also p

      C#auto-vectorisationauto-vectorizationburst
      View on GitHub↗8,127
    • tmodloader/tmodloadertModLoader avatar

      tModLoader/tModLoader

      5,099View on GitHub↗

      tModLoader is a modding framework and toolset designed for expanding game content and extending core game logic. It provides a polymorphic content API that allows for the creation of new items, NPCs, projectiles, and world assets through object-oriented inheritance. The project is distinguished by its advanced code modification capabilities, utilizing intermediate language bytecode patching and reflection-based private access to alter internal game behavior. It features a hot-reloading assembly runtime that enables developers to recompile and apply source code changes in real-time without res

      C#apigamesteam
      View on GitHub↗5,099
    Compare all 30 related projects→