lust-station

Gives a complete practical analysis of the AtmosSystem API in Space Station 14: what methods to use for what, which of them are fresh and safe, which ones are legacy/limited, and how to correctly combine calls in gameplay, devices and map-level logic.

Parses the AtmosSystem architecture in Space Station 14 at the server/shared/client level: processing cycle, tile state, invalidations, connection with DeltaPressure and overlay synchronization. Use it when you need to understand how the system actually works, where it is safe to expand, and how not to break the performance/consistency of the atmosphere.

Gives a practical catalog of the AudioSystem API in Space Station 14: when to use the Play/Set/Stop/Resolve methods, how to work with predicted audio and filters, and how to use OpenAL EFX (auxiliary/effect/preset) without common mistakes.

Explains the AudioSystem architecture in Space Station 14 at the shared/server/client and OpenAL levels: audio entity lifecycle, PVS filtering, occlusion, streaming and EFX chain. Use when you need to understand the internal design of a system before expanding or debugging.

SS14 Database System Guide (PostgreSQL and SQLite)

A practical documentation standard in Space Station 14 for C#, SWSL, YAML and FTL: how to write `<summary>`, when to add explanatory comments, how to document partial systems, and how to avoid noisy documentation. Use it when writing, refactoring and reviewing documentation in code, prototypes and localization.

Architecture guide for Component in Space Station 14 — data containers, attributes, networking, state-as-component pattern, and marker components

Working with entities in Space Station 14 — EntityUid, Entity<T>, implicit Entity<T>-as-EntityUid usage, component operations, containers, network identity, and entity lifecycle

YAML prototypes in Space Station 14 — entity definitions, field inheritance, prototype classes, YAML linter, naming conventions, and localization

Architecture guide for EntitySystem in Space Station 14 — lifecycle, events, queries, networking, prediction, and partial class decomposition patterns

Architectural guide to EventBus in Space Station 14 - strict event taxonomy, subscription storage, dispatch logic and internal optimization mechanisms.

A guide to using events in Space Station 14 - strict taxonomy, subscriptions, by-ref event prioritization, and networking patterns.

A deep practical guide to entity animations using the AnimationPlayerSystem in SS14: lifecycle, API, track types, keyframes/interpolation/easing, completion events, patterns and anti-patterns for production code.

A practical and architectural guide to the combination of AppearanceComponent, AppearanceSystem, VisualizerSystem and GenericVisualizer in SS14. Use it when designing network visual states, YAML visualizations and client visualizer systems.

An in-depth practical guide to the SS14 overlay architecture: OverlaySpace, lifecycle, communication with shaders, ScreenTexture, render targets, stencil composition, graphics primitives and render optimization.

An in-depth practical guide to SS14 and SWSL shaders: syntax, presets, built-in variables/functions, parameters, debugging and architectural solutions. Use it for tasks about shader prototype, uniform, light_mode/blend_mode, stencil, compatibility and GPU effects.

An in-depth practical guide to SpriteSystem in Space Station 14: lifecycle, full API for groups of methods, working with layers and layer-map, practical patterns and anti-patterns. Use it when developing dynamic sprites, visualizer systems and refactoring outdated SpriteComponent calls.

Creation, copying, renaming, migration and review of SS14 loadout prototypes (`roleLoadout`, `loadoutGroup`, `loadout`) in fork folders like `_Scp`: naming, isolation from vanilla, transfer of mandatory equipment from `startingGear`, `startingGear` synchronization and processing of hidden jobs/departments. Use when changing job prototypes and any loadout system files.

A guide to using localization in Space Station 14 C# code. Describes the ILocalizationManager, LocId, and proper dependency injection patterns.

A guide to working with localization files (.ftl) and strings in Space Station 14. Use this skill when adding or changing game text, item descriptions and interface.

Highly specialized skill in matrix transformations in SS14: world/grid/local/screen conversions, Sprite render matrices, broadphase-space physics queries, Transform/Physics/Sprite client and server chains.

Guide to Creating and Managing Database Migrations in SS14 (PostgreSQL and SQLite)

Strict naming standards in Space Station 14 for C#, YAML prototypes and FTL: names of components/systems/dependencies, prototype IDs, localization keys, variables and files. Use it when creating or reviewing new code, prototypes and localization, when you need to check compliance with the naming standard.

Architecture guide for networking in Space Station 14 — Lidgren integration, NetManager abstraction, message system, game state synchronization, PVS, network events, and component networking

Deep dive into the NPC system in SS14/Sunrise: HTN planning, utility target selection, steering/pathfinding, blackboard and execution contracts. Use it when you need to understand the general scheme and logic of NPCs, create or rework behavior prototypes (`htnCompound`, `rootTask`, `blackboard`), or write your own AI code (operators, preconditions, components, systems) and safely integrate it into runtime.

A complete reference to the SharedPhysicsSystem public API in Space Station 14: all method families, overloads, limitations, rare methods and practical examples of use on the server and client. Use it when you need to accurately select the PhysicsSystem method and not break contacts/collisions/prediction.

Deep practical guide to PhysicsSystem in Space Station 14: simulation device (broadphase, contacts, islands, solver), connection with Transform/Container/Anchoring, client prediction part and working application patterns. Use it when you need to understand how physics actually works and where it is safe to embed game logic.

Architecture guide for client-side prediction in Space Station 14 — prediction loop, timing properties, predicted entities, state reconciliation, randomness, and common pitfalls

Architecture guide for PVS in Space Station 14 — chunk-based spatial partitioning, visibility determination, override types, budgets, Level-of-Detail, leave mechanics, visibility masks, and ExpandPvsEvent

Creating and updating skills for sunrise-station/SS14: decomposing the topic into several narrow skills, researching fresh code and docs, forming patterns/anti-patterns, writing high-quality SKILL.md with examples and quality checks. Use it when you need to write a new skill, rework an existing skill, or systematically improve the skill pool.

Practical skill in standard optimizations of Space Station 14: caching, reduction of allocations, abandonment of LINQ in hot-path, ActiveComponent approach, EntityQuery, order of components in EntityQueryEnumerator, ByRef events, DirtyField, early exits and cleaning of unnecessary components. Use it when designing, reviewing and optimizing ECS ​​code in server/shared/client.

Practical workflow for writing your own unit/integration tests in the Space Station 14 architecture: from choosing a strategy to stable assertions and test maintenance.

An in-depth guide to the SS14 integration test framework: PoolManager, TestPair lifecycle, server/client synchronization, action emulation and pitfalls.

A complete reference book for the SharedTransformSystem API in Space Station 14: analysis of all public families of methods, selection of overloads, restrictions and practical application patterns on the server and client. Use when you need to accurately select the TransformSystem method and avoid coordinate space errors.

An in-depth practical guide to TransformSystem in Space Station 14: coordinate model (EntityCoordinates/MapCoordinates), parent-grid-map hierarchy, safe movement, anchor/unbind and client/server patterns. Use for teleports, entity transfers, containers, anchoring and spatial optimizations.

A practical guide to Bound User Interface (BUI) in SS14: architecture, network messages, input validation, prediction through component state, lifecycle windows and server-client working patterns. Use it when developing and refactoring entity-bound interfaces.

An in-depth practical guide to the combination of EUI, UserInterfaceSystem and UserInterfaceManager in SS14: choosing an approach, lifecycle, state/message exchange, window management via UIController and secure network patterns.

A practical guide to the SS14 style system: StyleClass, palettes, StyleProperties, sheetlets, pseudo-classes and rules composition. Use it when developing and refactoring a visual UI language without hardcode.

A practical guide to SS14 XAML interfaces: window structure, GenerateTypedNameReferences, loading via RobustXamlLoader, layout containers, localization and style classes. Use it when creating, refactoring and visually polishing UI windows.

Guide to working with Space Station 14 forks with project-folder pattern (`_Sunrise`, `_Scp`, `_Fish`, `_Lust`) to minimize merge conflicts with the upstream. Use when modifying vanilla code or prototypes.