open-space

Safely maintain a forked SS14 codebase with minimal upstream churn. Use when deciding whether to edit upstream files, when extending behavior in `_OpenSpace`, when preserving path similarity, or when avoiding unnecessary changes to RobustToolbox and offs content.

Work with SS14 atmospherics, gases, gas mixtures, fire, pressure, pipes, vents, pumps, scrubbers, air alarms, atmos overlays, and atmos-related prototypes or UI.

Work with SS14 audio systems, sound specifiers, sound collections, ambient or lobby music, jukeboxes, predicted sound feedback, or audio assets under `Resources/Audio` and `Resources/Prototypes/SoundCollections`.

Work with SS14 server database models, EF Core DbContexts, SQLite/Postgres migrations, persistence services, admin/player data storage, and schema compatibility.

Work with SS14 NPC systems, HTN behavior, pathfinding, steering, AI debug overlays, mindless mobs, hostile or friendly mob behavior, and NPC-related prototypes.

Work with SS14 PVS, visibility, network interest, PVS filters, PVS override behavior, visibility-dependent audio or popups, zoom PVS scale, or systems that behave differently when entities leave PVS.

Work with SS14 sprites, RSI metadata, sprite layers, overlays, custom visualizers, shaders, lighting-like client effects, and visual assets under `Resources/Textures` or client visual systems.

Work with SS14 transforms, coordinates, grids, maps, anchoring, containers, movement, collision, fixtures, physics bodies, thrown entities, or spatial queries.

Work with SS14 Bound User Interfaces, BUI state and messages, UI keys, `BoundUserInterface` client classes, server-side UI handlers, predicted BUI actions, and shared BUI contracts.

Work with SS14 EUI flows, `BaseEui`, `EuiStateBase`, `EuiMessageBase`, admin/debug windows, EUI state serialization, and client/server EUI message handling.

Work with SS14 XAML windows, controls, `.xaml.cs` code-behind, UI layout, style classes, localized UI text, FancyWindow patterns, and client-side UI widgets.

Use AI tools responsibly for SS14 development. Use when asking an agent to explain code, draft tests, refactor safely, debug with context, or when deciding what should stay human-designed versus what can be delegated to AI in this repo.

Learn or reason about the SS14 split between `Content.Client`, `Content.Shared`, and `Content.Server`. Use when deciding where code belongs, explaining prediction, understanding client/server trust boundaries, or mapping a feature across replication and networking.

Use common SS14 gameplay helper APIs correctly. Use when choosing between `TryComp`, `Resolve`, `EnsureComp`, `Spawn`, `EntityQueryEnumerator`, prototype lookups, audio methods, popup methods, or safe randomness patterns in gameplay code.

Debug SS14 gameplay and content issues. Use when tracing a bug through events or systems, deciding between logs and breakpoints, using View Variables or console tools, or checking for prediction misbehavior, runtime mismatches, and sync problems.

Learn or explain SS14 ECS architecture. Use when teaching or reasoning about entities, components, systems, and events; when reading an unfamiliar `*System.cs`; or when deciding what belongs in a component versus a system in this repo.

Create or modify SS14 ECS components in C#. Use when adding or reviewing component classes, component data fields, networked component state, serialization fields, or deciding what belongs in a component versus a system.

Create or modify SS14 prototypes and their paired content data. Use when editing entity, reagent, structure, item, or appearance prototypes; deciding where prototype files belong; or mapping C# changes to YAML, FTL, sounds, sprites, and other Resources content.

Write reviewable implementation notes for larger SS14 changes. Use when a gameplay change is large, when you need PR-ready technical notes, when a multi-file feature needs a brief internal write-up, or when a complex change should leave behind clear guidance for future edits.

Work with entities, entity-system APIs, and entity/component access patterns in SS14 C#. Use when designing public system method signatures, choosing between EntityUid and Entity<T>, or resolving components safely in gameplay code.

Create or modify SS14 entity systems in C#. Use when implementing gameplay logic, subscriptions, dependencies, public system APIs, or cross-assembly system placement for shared/server/client mechanics.

Create or review SS14 events and event-driven gameplay flow. Use when adding shared events, by-ref events, directed or relayed events, or deciding whether logic should be a public system method instead of a new event.

Implement or review gameplay code changes in this SS14 fork. Use when modifying C# entity systems, components, actions, events, or predicted interactions across `Content.Shared`, `Content.Server`, or `Content.Client`; when deciding which assembly or feature folder owns a mechanic; or when a gameplay change also needs prototypes, localization, UI, networking, or tests.

Work with SS14 visual state driven by `Appearance` and `GenericVisualizer`. Use when editing appearance enums, sprite-layer visibility rules, prototype-driven visual toggles, or shared/client visual state that maps gameplay state to RSIs.

Use localized text correctly from SS14 C# code. Use when storing `LocId`, calling `Loc.GetString(...)`, choosing between raw text and localized identifiers, formatting popup/chat/UI strings, or reading localized entity and prototype names from code.

Add or review SS14 localization strings and localized C# usage. Use when changing player-facing text, FTL keys, Loc.GetString calls, localized prototype names or descriptions, or ensuring gameplay and UI text is properly localized.

Apply SS14 naming conventions for C#, prototypes, events, dependencies, and localization. Use when naming handlers, methods, components, events, prototype IDs, localization IDs, or serialized fields in this repo.

Work with SS14 network events, `NetEntity`, replicated state, and shared/server/client routing. Use when adding or reviewing `[NetSerializable]` events, `SubscribeNetworkEvent`, networked component state, or deciding which assembly owns a networked message or replicated field.

Port features safely into this fork and respect the repository's license model. Use when importing code or assets from another repo, checking whether a source is acceptable, planning attribution, or deciding how fork-specific changes should be isolated and documented in `open-space`.

Implement or review predicted gameplay and networked state in SS14. Use when a player action should feel immediate, when touching networked components, predicted popups or audio, predicted BUI flows, or shared client/server system splits.

Learn or explain the basics of SS14 prototypes. Use when creating a first entity prototype, teaching prototype inheritance, finding where YAML lives, understanding common prototype components like `Sprite`, `Item`, `Tag`, or `Storage`, or when converting a rough gameplay idea into a prototype-first implementation plan.

Edit SS14 content resources under `Resources/`. Use when touching prototypes, localization, YAML, FTL, sprite metadata, sound collections, maps, or when mapping gameplay and UI code to the correct prototype, locale, texture, audio, or validation files.

Optimize SS14 gameplay code in common hot paths. Use when working on Update loops, frequently raised events, high-volume entity iteration, prediction-heavy client code, or other gameplay code where standard SS14 performance patterns matter.

Add or choose SS14 test coverage for gameplay, content, and integration changes. Use when deciding whether a change needs `Content.Tests`, `Content.IntegrationTests`, YAML validation, or only a targeted build/runtime pass, and when looking for in-repo test anchors to copy.