Railroader

https://github.com/tacticalcatboy/railroader-api-docs
Admin
Railroader is a game that provides a comprehensive API for modding, enabling developers to create...
Tokens:82,405
Snippets:1,398
Trust Score:4.8
Update:1 year ago
Show doc for...
Tokens:
Raw
================
LIBRARY RULES
================
- Use Unity Mod Manager (UMM) for loading mods into Railroader
- Use Harmony library for runtime patching of game methods
- Reference Model.Car class for working with cars and locomotives
- Reference Track.Location for track positioning and navigation
- Reference Game.Events namespace for game lifecycle events like MapDidLoadEvent
- Use GalaSoft.MvvmLight.Messaging for subscribing to game events
- Reference Model.Database.PrefabStore for accessing game asset definitions
- All mod entry points should implement UMM's Load method pattern
- Use Krafs.Publicizer to access internal game classes in your mod

================
CODE SNIPPETS
================
### ComponentSetup Setup Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/ComponentSetup.md

The Setup method for the ComponentSetup class. It initializes and configures a component based on provided parameters, including object name, component definition, setup context, parent transform, property observation, and prefab instantiation.

```csharp
public static void Setup(string objectName, Model.Definition.Component component, Context setupContext, Transform parent, Action<string, Action<Value>> observeProperty, IPrefabInstantiator prefabInstantiator)
```

--------------------------------

### Harmony Patching Example (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/README.md

Provides a basic example of how to use HarmonyLib for runtime patching of game methods. This allows modders to inject custom logic before or after original methods execute.

```csharp
using HarmonyLib;

[HarmonyPatch(typeof(TargetClass), "MethodName")]
public static class MyPatch {
    static bool Prefix() {
        // Your code
        return true; // false = skip original
    }
}
```

--------------------------------

### HostInfo Properties and Methods (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/HostInfo.md

Defines the public properties and private methods associated with the HostInfo struct. Includes an Action for starting a server and a private method to initiate the server start process.

```csharp
public Action<HostInfo> OnStartServer

private void StartServer()
```

--------------------------------

### Declare SetupDescriptor MonoBehaviour Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Progression/SetupDescriptor.md

Declares the SetupDescriptor class, inheriting from MonoBehaviour. This class is used to describe game setup configurations.

```csharp
public class SetupDescriptor : MonoBehaviour
```

--------------------------------

### StartGameSinglePlayer Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/MenuManager.md

This C# code defines the private method StartGameSinglePlayer within the MenuManager class. It takes a GameSetup object as input and is responsible for initiating a single-player game, likely handling the setup and transition to the game scene.

```csharp
private void StartGameSinglePlayer(GameSetup setup)
```

--------------------------------

### Declare SetupPrefabs Struct (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/SetupPrefabs.md

This snippet shows the declaration of the 'SetupPrefabs' struct in C#. It defines the basic structure that will hold prefab-related setup information.

```csharp
public struct SetupPrefabs
```

--------------------------------

### ComponentSetup Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/ComponentSetup.md

Declares the static ComponentSetup class within the Model namespace. This class serves as a utility for component setup operations.

```csharp
public static class ComponentSetup
```

--------------------------------

### IndustryContext Methods (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/IndustryContext.md

Details the methods available within the IndustryContext struct. The example provided is OrderWeightInTons, a private static method used to calculate order weight in tons.

```csharp
private static int OrderWeightInTons(TypedContainerItem<CarDefinition> definitionInfo, [CanBeNull] Load load)
```

--------------------------------

### Declare Section Struct in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Guide/Section.md

This snippet shows the declaration of the 'Section' struct within the 'UI.Guide' namespace. It is a fundamental data structure used for organizing content within a guide.

```csharp
public struct Section
```

--------------------------------

### Preference Key Constants (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Preferences.md

This section lists numerous private constant string fields used as keys for storing various game preferences. These constants ensure consistency in how preference data is accessed and stored, preventing typos and simplifying updates. Examples include keys for analytics, avatar, graphics settings, controls, sound, and mouse look.

```csharp
private const string KeyAnalytics = "analytics";
private const string KeyAvatarDescriptor = "avatarDescriptor";
private const string KeyGfxTreeDensity = "gfxTreeDensity";
private const string KeyGfxDetailDensity = "gfxDetailDensity";
private const string KeyGfxAntiAliasing = "gfxAntiAliasing";
private const string KeyGfxVsync = "gfxVsync";
private const string KeyGfxFPSLimit = "gfxFPSLimit";
private const string KeyGfxCanvasScale = "gfxCanvasScale";
private const string KeyGfxNightLightLevel = "gfxNightLightLevel";
private const string KeyGfxPostExposure = "gfxPostExposure";
private const string KeyGfxContrast = "gfxContrast";
private const string KeySimplifiedControls = "simplifiedControls";
private const string KeyCarUpdateOptimization = "carUpdateOptimization";
private const string KeyHostAuthLogging = "hostAuthLogging";
private const string KeySwayIntensity = "swayIntensity";
private const string KeyMouseLookSpeed = "mouseLookSpeed";
private const string KeyMouseLookInvert = "mouseLookInvert";
private const string KeyMouseLookToggle = "mouseLookToggle";
private const string KeySoundVolumeMain = "soundVolumeMain";
private const string KeySoundVolumeEngine = "soundVolumeEngine";
private const string KeySoundVolumeWhistle = "soundVolumeWhistle";
private const string KeySoundVolumeBell = "soundVolumeBell";
private const string KeySoundVolumeDynamo = "soundVolumeDynamo";
private const string KeySoundVolumeEnvironment = "soundVolumeEnvironment";
private const string KeySoundVolumeCtcBell = "soundVolumeCtcBell";
private const string KeySoundVolumeWheels = "soundVolumeWheels";
```

--------------------------------

### Subscribe to Game Lifecycle Events using MVVM Light Messenger

Source: https://context7.com/tacticalcatboy/railroader-api-docs/llms.txt

This C# snippet demonstrates how to subscribe to game lifecycle events such as map loading, time changes, and car state updates using GalaSoft MVVM Light Messenger. It requires the GalaSoft.MvvmLight.Messaging, Game.Events, and UnityModManagerNet namespaces. The example includes methods for handling each event and logging messages.

```csharp
using GalaSoft.MvvmLight.Messaging;
using Game.Events;
using UnityModManagerNet;

public class MyMod
{
    private static UnityModManager.ModEntry modEntry;

    static bool Load(UnityModManager.ModEntry entry)
    {
        modEntry = entry;

        // Subscribe to map load event
        Messenger.Default.Register<MapDidLoadEvent>(entry, OnMapDidLoad);

        // Subscribe to time change events
        Messenger.Default.Register<TimeMinuteDidChange>(entry, OnTimeMinuteChanged);

        // Subscribe to car state changes
        Messenger.Default.Register<CarDefinitionDidChangeEvent>(entry, OnCarChanged);

        modEntry.Logger.Log("Mod loaded and subscribed to events");
        return true;
    }

    private static void OnMapDidLoad(MapDidLoadEvent evt)
    {
        modEntry.Logger.Log("Map loaded - initializing mod systems");
        // Initialize your mod's systems after the map loads
    }

    private static void OnTimeMinuteChanged(TimeMinuteDidChange evt)
    {
        // React to in-game time progression
        modEntry.Logger.Log($"Game time advanced to minute {evt.Minute}");
    }

    private static void OnCarChanged(CarDefinitionDidChangeEvent evt)
    {
        modEntry.Logger.Log($"Car {evt.CarId} definition changed");
    }
}
```

--------------------------------

### MapWindow Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Map/MapWindow.md

Declares the MapWindow class, inheriting from MonoBehaviour, which is a fundamental class in Unity for game objects. It serves as the base for scripts that manage game logic and behaviors. This declaration indicates the start of a Unity component script.

```csharp
public class MapWindow : MonoBehaviour
```

--------------------------------

### StartServer Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/MultiplayerHostMenu.md

The StartServer method within the MultiplayerHostMenu class. This private method is responsible for initiating the server hosting process.

```csharp
private void StartServer()
```

--------------------------------

### GuideWindow Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Guide/GuideWindow.md

Declares the GuideWindow class as a MonoBehaviour and an implementation of the IBuilderWindow interface in Unity. It serves as a foundation for UI window components.

```csharp
public class GuideWindow : MonoBehaviour, IBuilderWindow
```

--------------------------------

### Get TrackSegment Length (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Track/TrackSegment.md

Provides the method to calculate and retrieve the length of the TrackSegment. This method is essential for pathfinding or simulation calculations.

```csharp
public float GetLength()
```

--------------------------------

### SetupAnimation Method in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/RollingStock/Bell.md

The 'SetupAnimation' method is a private method within the Bell class, responsible for initializing or configuring animation-related components. Its implementation details are not provided here but are crucial for animation playback.

```csharp
private void SetupAnimation()
```

--------------------------------

### Declare VisualTimetableEditor Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Timetable/VisualTimetableEditor.md

This C# code snippet shows the declaration of the VisualTimetableEditor class, indicating it inherits from BaseTimetableEditor. It signifies the start of a UI component for timetable editing.

```csharp
public class VisualTimetableEditor : BaseTimetableEditor
```

--------------------------------

### C# AudioReparenter SetupRigidbody Method

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/AudioReparenter.md

Defines the private SetupRigidbody method within the AudioReparenter class. This method is intended for internal use to configure the Rigidbody component associated with the audio object.

```csharp
private void SetupRigidbody()
```

--------------------------------

### PrepareSources Method Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/IntegerLoopingPlayer.md

This C# snippet shows the declaration of the PrepareSources method within the IntegerLoopingPlayer class. This method is likely responsible for initializing audio sources or clips before playback.

```csharp
public void PrepareSources()
```

--------------------------------

### Calculate Tractive Effort Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Physics/PrimeMover.md

This private static method calculates the tractive effort based on speed (mph) and starting tractive effort. It is a utility function within the PrimeMover class.

```csharp
private static float CalculateTractiveEffort(float mph, float startingTractiveEffort)
```

--------------------------------

### ArraySegmentReadStream Position Property (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Network/Buffers/ArraySegmentReadStream.md

This shows the overridden 'Position' property for the ArraySegmentReadStream class. This property allows for getting and setting the current position within the stream, which is represented by an ArraySegment<byte>.

```csharp
public override long Position { get; }
```

--------------------------------

### ActualReturnAfterFinished Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/VirtualAudioSourcePool.md

Implements the `ActualReturnAfterFinished` method, which is private and takes an `IAudioSource` as input. This method likely handles the logic for returning a finished audio source back to the pool.

```csharp
private void ActualReturnAfterFinished(IAudioSource audioSource)
```

--------------------------------

### GetStartEndIndexFloat Method in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/LazyScrollList/LazyScrollList.md

This private method, GetStartEndIndexFloat, is used internally by LazyScrollList to calculate the starting and ending indices for visible elements, likely represented as floating-point values. It outputs these indices via `out` parameters.

```csharp
private void GetStartEndIndexFloat(out float startIndex, out float endIndex)
```

--------------------------------

### Configure Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/Info.md

Defines the 'Configure' method for the 'Info' class. This method is private and likely used internally to set up the UI elements or data associated with a lobby based on provided parameters.

```csharp
private void Configure(string lobbyName, string version, string countText, bool allowNewPlayers, bool passworded)
```

--------------------------------

### ClickedGuide Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/TopRightArea.md

This snippet defines the ClickedGuide method within the TopRightArea class. This method is public and returns void, suggesting it is an event handler or a simple action trigger.

```csharp
public void ClickedGuide()
```

--------------------------------

### Declare Context Struct - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Context.md

This C# code snippet shows the declaration of the 'Context' struct within the 'Model' namespace. It is a fundamental structure used for context management within the component setup process.

```csharp
public struct Context
```

--------------------------------

### OnStarted Method Implementation (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/VirtualRepeatingInput.md

This snippet presents the private OnStarted method, which takes an InputAction.CallbackContext as an argument. This method is likely an event handler for input actions within the VirtualRepeatingInput class.

```csharp
private void OnStarted(InputAction.CallbackContext obj)
```

--------------------------------

### RadialAnimatedControl Properties (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/RollingStock/ContinuousControls/RadialAnimatedControl.md

This section lists the public properties of the RadialAnimatedControl class. These properties provide access to control attributes such as purpose, rotation start and extent, radius, and behavior modifiers like momentary activation and shift toggling.

```csharp
public ControlPurpose ControlComponentPurpose { get; }
```

--------------------------------

### Configure SwitchStand Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Track/SwitchStand.md

The Configure method allows the SwitchStand to be set up with a specific TrackNode. This method is crucial for associating the visual switch stand with its logical track representation.

```csharp
public void Configure(TrackNode node)
```

--------------------------------

### Get Authorization Requirement for Property Write (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/AccessControl/StaticPropertyAccessControlDelegate.md

This method, AuthorizationRequirementForPropertyWrite, is part of the StaticPropertyAccessControlDelegate struct. It takes a string key representing a property and returns an AuthorizationRequirementInfo object. This is used to determine the authorization needed to write to the specified property.

```csharp
public AuthorizationRequirementInfo AuthorizationRequirementForPropertyWrite(string key)
```

--------------------------------

### TutorialManager Shared Property (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Tutorial/TutorialManager.md

This snippet defines the static 'Shared' property of the TutorialManager class. This property provides global access to a single instance of the TutorialManager, a common pattern in Unity for managers.

```csharp
public static TutorialManager Shared
```

--------------------------------

### C# Method Declaration: CalculateRepairWork

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/RepairTrack.md

Defines the static method CalculateRepairWork, which likely computes the amount of repair work needed for a car. It takes a Car object, an optional repair capacity override, and an optional starting condition as input, returning a float value representing the calculated work.

```csharp
private static float CalculateRepairWork(Car car, float repairCapOverride, float? startCondition = null)
```

--------------------------------

### Show PreferencesWindow Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/PreferencesWindow/PreferencesWindow.md

Provides a static method to display the PreferencesWindow. This is the primary way to access and interact with the preferences UI.

```csharp
public static void Show()
```

--------------------------------

### BuildPole Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/TelegraphPoles/WireSet.md

This snippet shows the method signature for BuildPole, a private method within the WireSet class. It takes a SimpleGraph.Runtime.SimpleGraph and a Node as input.

```csharp
private void BuildPole(SimpleGraph.Runtime.SimpleGraph graph, Node node)
```

--------------------------------

### Create Singleplayer ConnectionInfo (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Network/ConnectionInfo.md

This snippet defines the static method 'Singleplayer' for creating a ConnectionInfo instance for a singleplayer game. It requires a username and character customization data as input.

```csharp
public static ConnectionInfo Singleplayer(string username, Snapshot.CharacterCustomization customization)
```

--------------------------------

### Create Wall Triangles Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/RealWorldTerrainBuilding.md

This C# code defines the signature for the private method CreateWallTriangles within the RealWorldTerrainBuilding class. It takes a list of vertices, an offset integer, and a boolean for reversal, returning a list of integers representing triangles.

```csharp
private List<int> CreateWallTriangles(List<Vector3> vertices, int offset, bool reversed)
```

--------------------------------

### Configure BuilderPhoto Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Equipment/BuilderPhoto.md

This C# method, Configure, is part of the BuilderPhoto class. It is an asynchronous method designed to configure the photo display, likely by loading or setting an image based on a provided car identifier string. It utilizes a CancellationTokenSource for managing asynchronous operations.

```csharp
public async void Configure(string carIdentifier)
```

--------------------------------

### StartObserving Method Implementation

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/RollingStock/Controls/KeyValueBoolActivator.md

This C# method, StartObserving, is a private IEnumerator used within the KeyValueBoolActivator class. Its specific functionality is not detailed here but implies an observable or asynchronous process.

```csharp
private IEnumerator StartObserving()
```

--------------------------------

### Configure Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CompanyWindow/Info.md

This snippet displays the signature for the private Configure method within the Info class. This method is intended for internal use and its implementation details are not provided here. It resides in the UI.CompanyWindow namespace.

```csharp
private void Configure()
```

--------------------------------

### CompanyWindow Methods (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CompanyWindow/CompanyWindow.md

This section documents the private methods of the CompanyWindow class. The 'WindowShownDidChange' method is a private void method that takes a boolean argument 'shown', suggesting it's a callback or handler for changes in the window's visibility state.

```csharp
private void WindowShownDidChange(bool shown)
```

--------------------------------

### Declare TutorialManager Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Tutorial/TutorialManager.md

This snippet shows the declaration of the TutorialManager class, indicating it inherits from MonoBehaviour. This is a fundamental part of Unity scripting for game objects.

```csharp
public class TutorialManager : MonoBehaviour
```

--------------------------------

### SetInitialPositionSize Method for Window in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Common/WindowRecord.md

An extension method for the Window class that sets the initial position and size. It takes an identifier, default size, default position, and sizing parameters.

```csharp
public static void SetInitialPositionSize(this Window window, string identifier, Vector2 defaultSize, Window.Position defaultPosition, Window.Sizing sizing)
```

--------------------------------

### Harmony Patching Game Methods in C#

Source: https://context7.com/tacticalcatboy/railroader-api-docs/llms.txt

Demonstrates how to use HarmonyLib for runtime patching of game methods. This includes creating prefix and postfix patches for method calls, patching property getters, and using transpilers for advanced IL manipulation. It relies on UnityModManagerNet for logging and mod management.

```csharp
using HarmonyLib;
using Model;
using UnityModManagerNet;

public class HarmonyPatches
{
    public static void ApplyPatches(UnityModManager.ModEntry entry)
    {
        var harmony = new Harmony(entry.Info.Id);
        harmony.PatchAll();
        entry.Logger.Log("Harmony patches applied");
    }

    // Prefix patch - runs before the original method
    [HarmonyPatch(typeof(Car), nameof(Car.UpdateBrakeApplied))]
    public static class CarBrakePatch
    {
        static bool Prefix(Car __instance, bool brakeApplied)
        {
            // __instance is the Car object
            UnityModManager.Logger.Log($"Brake applied on car {__instance.id}: {brakeApplied}");

            // Return true to continue to original method
            // Return false to skip original method execution
            return true;
        }

        static void Postfix(Car __instance, bool brakeApplied)
        {
            // Runs after the original method
            UnityModManager.Logger.Log($"Brake update completed for {__instance.id}");
        }
    }

    // Patching a property getter
    [HarmonyPatch(typeof(BaseLocomotive), "IsIdle", MethodType.Getter)]
    public static class LocomotiveIdlePatch
    {
        static void Postfix(BaseLocomotive __instance, ref bool __result)
        {
            // __result contains the return value
            if (__result)
            {
                UnityModManager.Logger.Log($"Locomotive {__instance.id} is idle");
            }
        }
    }

    // Transpiler patch for advanced IL code manipulation
    [HarmonyPatch(typeof(DieselLocomotive), nameof(DieselLocomotive.CreateLocomotiveControl))]
    public static class DieselControlPatch
    {
        static bool Prefix(DieselLocomotive __instance, ref LocomotiveControlAdapter __result)
        {
            // Replace the entire method with custom logic
            UnityModManager.Logger.Log($"Creating custom locomotive control for {__instance.id}");
            // __result = new CustomLocomotiveControl();
            // return false; // Skip original method
            return true;
        }
    }
}

```

--------------------------------

### BuildDetails Method Signature

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Equipment/EquipmentWindow.md

Signature for the private BuildDetails method within the EquipmentWindow class. This method is likely responsible for constructing the detailed view of an equipment item using a UIPanelBuilder, identifier, ObjectMetadata, and DieselLocomotiveDefinition.

```csharp
private void BuildDetails(UIPanelBuilder builder, string identifier, ObjectMetadata metadata, DieselLocomotiveDefinition def)
```

--------------------------------

### Configure Method for QuickSearchResultRow (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/QuickSearch/QuickSearchResultRow.md

This C# method, Configure, is part of the QuickSearchResultRow class. It takes an integer listIndex and an object data as parameters, likely to set up the cell's content and position within a list.

```csharp
public void Configure(int listIndex, object data)
```

--------------------------------

### SceneLoadSetup Struct Declaration

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/SceneLoadSetup.md

Declares the SceneLoadSetup struct, a read-only structure used for configuring scene loading operations. It belongs to the UI.Menu namespace and is defined in GlobalGameManager.cs.

```csharp
public readonly struct SceneLoadSetup
```

--------------------------------

### CompanyWindow Properties (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CompanyWindow/CompanyWindow.md

This documentation details the public properties of the CompanyWindow class. The 'ShownPath' property is a string that likely indicates the current path or visibility state of the company window UI.

```csharp
public string ShownPath;
```

--------------------------------

### ShortTimeFourierTransform Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/DynamicChuff/SmbPitchShifter.md

Implements the Short Time Fourier Transform (STFT) algorithm. This method takes an FFT buffer, frame size, and a sign as input to perform spectral analysis and transformation, crucial for pitch shifting.

```csharp
public void ShortTimeFourierTransform(float[] fftBuffer, long fftFrameSize, long sign)
```

--------------------------------

### Create AvatarDescriptor From Customization (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Avatar/AvatarDescriptor.md

This snippet demonstrates the static method 'From' for creating an AvatarDescriptor instance from a Snapshot.CharacterCustomization object. The input is a customization object, and the output is an AvatarDescriptor.

```csharp
public static AvatarDescriptor From(Snapshot.CharacterCustomization customization)
```

--------------------------------

### C# SoundSettingsApplicator Class Declaration

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Settings/SoundSettingsApplicator.md

Declares the SoundSettingsApplicator class, inheriting from MonoBehaviour. This class is likely used to manage audio settings within the game.

```csharp
public class SoundSettingsApplicator : MonoBehaviour
```

--------------------------------

### CompanyWindow Fields (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CompanyWindow/CompanyWindow.md

This documentation lists the various private and public fields within the CompanyWindow class. It includes constants for tab identifiers, internal UI components like '_window' and '_panel', state management objects, and a static instance for singleton-like access.

```csharp
private const string TabIdRailroad = "...";
private const string TabIdMilestones = "...";
private const string TabIdFinance = "...";
private const string TabIdLocations = "...";
private const string TabIdEquipment = "...";
private const string TabIdEmployees = "...";
private const string TabIdCrews = "...";
private const string TabIdSettings = "...";
private Window _window;
private static CompanyWindow _instance;
private readonly UIState<string> _selectedTabState;
private readonly UIState<string> _selectedGoalsItem;
private readonly UIState<string> _selectedLocationsItem;
private readonly UIState<string> _selectedSettingsItem;
private readonly UIState<string> _selectedCarItem;
private readonly UIState<string> _selectedTrainCrewId;
private readonly UIState<string> _selectedPlayerId;
private UIPanel _panel;
public static CompanyWindow Shared;
```

--------------------------------

### UITooltipProvider Methods (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Tooltips/UITooltipProvider.md

This C# snippet defines a private method 'DynamicTooltipInfo' within the UITooltipProvider class. The return type is not explicitly specified in the provided declaration, but it's named to suggest it provides dynamic tooltip information.

```csharp
private return DynamicTooltipInfo()
```

--------------------------------

### Declare InstanceInfo Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Track/InstanceInfo.md

This C# code snippet declares the private class 'InstanceInfo' within the 'Track' namespace. It serves as a data structure for managing information related to prefab instances, likely for GPU instancing.

```csharp
private class InstanceInfo
```

--------------------------------

### Configure Unity Console Logging with Serilog

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Logging/SerilogUnityConsoleExtensions.md

The UnityConsole method is an extension method for LoggerSinkConfiguration that allows you to configure Serilog to write log events to the Unity console. It accepts an output template and an optional format provider. This is useful for debugging and monitoring application logs within the Unity environment.

```csharp
public static LoggerConfiguration UnityConsole(this LoggerSinkConfiguration sinkConfiguration, string outputTemplate = "[{Level:u}] {Message:lj} {Properties}{NewLine}{Exception}", IFormatProvider formatProvider = null)
```

--------------------------------

### Load Method for OpsCarAdapter (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/OpsCarAdapter.md

Defines the Load method for the OpsCarAdapter struct. This method is responsible for loading a specified quantity of a given Load onto the car.

```csharp
public float Load(Load load, float quantityToLoad)
```

--------------------------------

### C# Entry Struct Properties and Methods

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/Timetable/Entry.md

Details the public properties and methods of the Entry struct. Includes DisplayStringLong property and Equals method.

```csharp
public string DisplayStringLong { get; }
private return Equals(other);
```

--------------------------------

### Sizing Struct Fields (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Common/Sizing.md

Lists the fields of the Sizing struct, including private members for managing panel resizing, draggability, closure requests, and internal state related to resizing and UI elements.

```csharp
private PanelResizer resizer;
private DraggablePanel draggablePanel;
public Action DelegateRequestClose;
private bool _resizable;
private bool _hasRestoredSize;
private RectTransform _rectTransform;
```

--------------------------------

### BuildWindowContent Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/LostCarPlacer/LostCarPlacerWindow.md

This snippet defines the signature for the private BuildWindowContent method. This method is responsible for constructing the UI elements within the LostCarPlacerWindow, utilizing a UIPanelBuilder.

```csharp
private void BuildWindowContent(UIPanelBuilder builder)
```

--------------------------------

### Configure EditorSelectableCell Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CarEditor/Cells/EditorSelectableCell.md

This C# method, Configure, is used to set up an instance of EditorSelectableCell. It accepts text to display, a boolean to determine component enabled state, and an action to be executed on click.

```csharp
public void Configure(string text, bool componentEnabled, Action onClick)
```

--------------------------------

### ShowLoadingScreen Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/PersistentLoader.md

The ShowLoadingScreen method controls the visibility of the loading screen. It accepts a boolean parameter to determine whether to show or hide the screen.

```csharp
public void ShowLoadingScreen(bool show)
```

--------------------------------

### Declare EquipmentWindow Class

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Equipment/EquipmentWindow.md

Declaration of the EquipmentWindow class, inheriting from MonoBehaviour and implementing the IBuilderWindow interface. This is a fundamental C# class definition for a Unity UI component.

```csharp
public class EquipmentWindow : MonoBehaviour, IBuilderWindow
```

--------------------------------

### ApplyDensityAfterDelay Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/PreferencesWindow/PreferencesBuilder.md

This snippet defines the private static method ApplyDensityAfterDelay. It accepts a UIPanelBuilder object as input and is used for applying UI density settings after a delay.

```csharp
private static void ApplyDensityAfterDelay(UIPanelBuilder builder)
```

--------------------------------

### Create Custom UI Window with C#

Source: https://context7.com/tacticalcatboy/railroader-api-docs/llms.txt

This C# script provides a blueprint for creating a custom, draggable UI window within the game. It utilizes Unity's GameObject and Component system, along with the `TMPro` library for text elements. The `CustomUIWindow` class implements `IProgrammaticWindow` and handles initialization, showing, hiding, content updates, and proper destruction of the UI elements.

```csharp
using UI;
using UnityEngine;
using TMPro;

public class CustomUIWindow : MonoBehaviour, IProgrammaticWindow
{
    private GameObject windowObject;
    private TextMeshProUGUI titleText;
    private TextMeshProUGUI contentText;

    public void Initialize()
    {
        // Create window GameObject
        windowObject = new GameObject("CustomModWindow");
        windowObject.transform.SetParent(GameObject.Find("Canvas").transform);

        // Add draggable panel component
        var draggablePanel = windowObject.AddComponent<DraggablePanel>();

        // Create UI elements
        titleText = CreateTextElement("Title", windowObject.transform);
        titleText.text = "My Custom Mod Window";
        titleText.fontSize = 24;

        contentText = CreateTextElement("Content", windowObject.transform);
        contentText.text = "Window content goes here";
        contentText.fontSize = 16;

        Debug.Log("Custom UI window initialized");
    }

    private TextMeshProUGUI CreateTextElement(string name, Transform parent)
    {
        var obj = new GameObject(name);
        obj.transform.SetParent(parent);
        var text = obj.AddComponent<TextMeshProUGUI>();
        return text;
    }

    public void Show()
    {
        windowObject.SetActive(true);
    }

    public void Hide()
    {
        windowObject.SetActive(false);
    }

    public void UpdateContent(string newContent)
    {
        contentText.text = newContent;
    }

    public void OnDestroy()
    {
        if (windowObject != null)
        {
            Destroy(windowObject);
        }
    }
}

// Using the custom window
public class ModUIManager
{
    private CustomUIWindow customWindow;

    public void Setup()
    {
        customWindow = new GameObject("ModUI").AddComponent<CustomUIWindow>();
        customWindow.Initialize();
    }

    public void ToggleWindow()
    {
        if (customWindow.windowObject.activeSelf)
        {
            customWindow.Hide();
        }
        else
        {
            customWindow.Show();
        }
    }
}
```

--------------------------------

### VirtualAudioSourcePool Instance Property (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/VirtualAudioSourcePool.md

Defines a private static property `Instance` of type `VirtualAudioSourcePool`. This pattern suggests a Singleton design, providing a globally accessible point to the audio source pool.

```csharp
public VirtualAudioSourcePool Instance { get; private set; }
```

--------------------------------

### HandleLobbyGameCreated Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Network/Steam/ClientLobbyHelper.md

This method, HandleLobbyGameCreated, is a private method within the ClientLobbyHelper class. It takes a LobbyGameCreated_t argument and is likely used to process game creation events within a lobby.

```csharp
private void HandleLobbyGameCreated(LobbyGameCreated_t arg)
```

--------------------------------

### WillAppear Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/BuilderMenuBase.md

Defines the WillAppear method for the BuilderMenuBase class. This method is typically called just before a UI panel or menu becomes visible.

```csharp
public void WillAppear()
```

--------------------------------

### Declare GuideIndex Struct (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Guide/GuideIndex.md

This C# code declares the GuideIndex struct, defining its basic structure. It belongs to the UI.Guide namespace and is defined in GuideWindow.cs.

```csharp
public struct GuideIndex
```

--------------------------------

### SetInitialVisibility Method - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Track/Entry.md

This method, SetInitialVisibility, is part of the Entry class and is responsible for setting the initial visibility state of an Entry object. It takes an Entry object as a parameter.

```csharp
private void SetInitialVisibility(Entry entry)
```

--------------------------------

### BuildFreightTab Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/StationWindow/StationWindow.md

Defines the signature for the BuildFreightTab method. This private method within StationWindow likely handles the construction or population of a freight tab within a UI panel, taking builder, areas, and freight car data as input.

```csharp
private void BuildFreightTab(UIPanelBuilder builder, List<Area> areas, OpsCarList freightCars)
```

--------------------------------

### Link Class Properties (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Utils/Link.md

This documentation outlines the public and private fields (properties) of the Link class. It details their types and access levels, providing insight into the data managed by the Link object.

```csharp
public double maxlon;
public string author;
public string license;
private double _minlat;
private double _minlon;
private double _maxlat;
private double _maxlon;
public string id;
public string domain;
public string href;
public string text;
public string type;
public string name;
public string description;
public Person author;
public Copyright copyright;
public List<Link> links;
public string keywords;
public Bounds bounds;
public RealWorldTerrainXML extensions;
public string name;
public EMail email;
public Link link;
public string name;
public string comment;
public string description;
public string source;
public List<Link> links;
public string type;
public List<Waypoint> points;
public RealWorldTerrainXML extensions;
public string name;
public string comment;
public string description;
public string source;
public List<Link> links;
public string type;
public List<TrackSegment> segments;
public RealWorldTerrainXML extensions;
public List<Waypoint> points;
public RealWorldTerrainXML extensions;
public string name;
public string comment;
public string description;
public string source;
public List<Link> links;
public string symbol;
public string type;
public string fix;
public RealWorldTerrainXML extensions;
private double _lat;
private double _lon;
public string version;
public string creator;
public Meta metadata;
public List<Waypoint> waypoints;
public List<Route> routes;
public List<Track> tracks;
public RealWorldTerrainXML extensions;
```

--------------------------------

### Declare LocalGameClient Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Network/Client/LocalGameClient.md

This snippet shows the declaration of the LocalGameClient class, which inherits from GameClient and implements IServerManager. It is part of the Network.Client namespace.

```csharp
public class LocalGameClient : GameClient, IServerManager
```

--------------------------------

### Declare QuickSearchController Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/QuickSearch/QuickSearchController.md

Declares the QuickSearchController class, inheriting from MonoBehaviour. This class is part of the UI.QuickSearch namespace and is defined in QuickSearchController.cs. It serves as a controller for quick search functionalities within the UI.

```csharp
public class QuickSearchController : MonoBehaviour
```

--------------------------------

### Declare Info Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/CompanyWindow/Info.md

This snippet shows the basic declaration of the Info class in C#. It is part of the UI.CompanyWindow namespace and is defined in the LedgerRow.cs source file. No specific dependencies are mentioned for this declaration itself.

```csharp
public class Info
```

--------------------------------

### InstantiateCell Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Placer/ConsistEntry.md

This snippet defines the InstantiateCell method, which takes a ConsistEntry and an index as parameters. It's a private method, suggesting it's an internal helper function for managing UI elements related to consist entries.

```csharp
private void InstantiateCell(ConsistEntry entry, int index)
```

--------------------------------

### HandleRequestCreateTrainCrew Method - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/State/PlayerCameraPosition.md

This snippet defines the HandleRequestCreateTrainCrew method, which is part of the PlayerCameraPosition struct. It takes an IPlayer sender and a Snapshot.TrainCrew object as input and is declared as a public void method.

```csharp
public void HandleRequestCreateTrainCrew(IPlayer sender, Snapshot.TrainCrew trainCrew)
```

--------------------------------

### Define CreateLine Method in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Console/Entry.md

This snippet defines the 'CreateLine' method for the 'Entry' struct. This method takes text and a parent transform as input and is expected to return a TMP_Text object, likely for displaying text in a UI console.

```csharp
public TMP_Text CreateLine(string text, Transform parent)
```

--------------------------------

### Declare JoinInfo Struct - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/JoinInfo.md

This snippet shows the basic declaration of the JoinInfo struct. It defines the structure's existence within the UI.Menu namespace. No specific dependencies are required for this declaration itself.

```csharp
public struct JoinInfo
```

--------------------------------

### Subscribe to Game Events (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/README.md

Demonstrates how to subscribe to game events using the GalaSoft.MvvmLight.Messaging library. This pattern is useful for reacting to specific game occurrences like map loading.

```csharp
using GalaSoft.MvvmLight.Messaging;
using Game.Events;

Messenger.Default.Register<MapDidLoadEvent>(this, OnMapDidLoad);
```

--------------------------------

### TimelyDeliveryBonus Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/Contract.md

Calculates the bonus payment for timely delivery based on the number of days and base payment. This method is part of the Contract struct.

```csharp
public int TimelyDeliveryBonus(int days, int basePayment)
```

--------------------------------

### C# AudioSourcePool CreateAudioSource Method

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/AudioSourcePool.md

This snippet defines the private static method CreateAudioSource within the AudioSourcePool class. This method is responsible for the creation of an AudioSource, likely to be managed by the pool. It is marked as private, indicating it's an internal helper method.

```csharp
private static AudioSource CreateAudioSource()
```

--------------------------------

### C# Method: SnapToGround

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Cameras/StrategyCameraController.md

Defines the SnapToGround method within StrategyCameraController. This private method takes a position and an optional boolean for immediate adjustment, likely used to align the camera with ground geometry.

```csharp
private Vector3 SnapToGround(Vector3 position, bool immediate = false)
```

--------------------------------

### UITooltipProvider Fields (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Tooltips/UITooltipProvider.md

This C# snippet lists the fields of the UITooltipProvider class. It includes a public function delegate 'DynamicTooltipInfo' for providing tooltip info, and private string fields 'tooltipTitle' and 'tooltipText' for storing tooltip content.

```csharp
public Func<TooltipInfo> DynamicTooltipInfo
```

```csharp
private string tooltipTitle
```

```csharp
private string tooltipText
```

--------------------------------

### IsFull Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/MockCar.md

Defines the IsFull method for the MockCar class. This method checks if the car is full based on the provided Load object. It returns a boolean value indicating the status.

```csharp
public bool IsFull(Load load)
```

--------------------------------

### Declare Person Class - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Utils/Person.md

This snippet shows the basic declaration of the 'Person' class within the InfinityCode.RealWorldTerrain.Utils namespace. It serves as a blueprint for creating Person objects in C#.

```csharp
public class Person
```

--------------------------------

### Declare Link Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Utils/Link.md

This snippet shows the declaration of the Link class within the InfinityCode.RealWorldTerrain.Utils namespace. It serves as a base for defining various link-related properties and functionalities.

```csharp
public class Link
```

--------------------------------

### Configure Auto Engineer AI

Source: https://context7.com/tacticalcatboy/railroader-api-docs/llms.txt

Sets up and configures the Auto Engineer AI for autonomous train operation. This includes setting up the AutoEngineer component, configuring orders, route planning, and managing contextual behaviors. Dependencies include `Model.AI`, `Model`, `Track`, and `UnityEngine`.

```C#
using Model.AI;
using Model;
using Track;
using UnityEngine;
using System.Collections.Generic;

public class AutoEngineerManager
{
    private AutoEngineer autoEngineer;
    private Orders orders;

    public void SetupAutoEngineer(BaseLocomotive locomotive)
    {
        // Get or create Auto Engineer component
        autoEngineer = locomotive.GetComponent<AutoEngineer>();

        if (autoEngineer == null)
        {
            Debug.LogError("Auto Engineer not available on locomotive");
            return;
        }

        // Check Auto Engineer state
        State currentState = autoEngineer.State;
        Debug.Log($"Auto Engineer state: {currentState}");
    }

    public void ConfigureOrders(Location destination, float targetSpeed)
    {
        // Create new orders
        orders = new Orders();

        // Add waypoint to orders
        OrderWaypoint waypoint = new OrderWaypoint
        {
            Location = destination,
            TargetSpeed = targetSpeed
        };

        Debug.Log($"Configured Auto Engineer to travel to destination at {targetSpeed} mph");
    }

    public void SetContextualOrder(ContextualOrder order)
    {
        // Apply contextual behavior
        Debug.Log($"Setting contextual order: {order}");
    }

    public void ConfigurePlanner(AutoEngineerPlanner planner)
    {
        if (planner == null) return;

        // Configure route planning
        Debug.Log("Configuring Auto Engineer planner");
    }

    public void SetupPassengerStopper(AutoEngineerPassengerStopper stopper)
    {
        if (stopper == null) return;

        // Configure automatic passenger stops
        Debug.Log("Configured passenger stop handler");
    }

    public void EnableFuelAlerter(AutoEngineerFuelAlerter alerter)
    {
        if (alerter == null) return;

        // Enable low fuel warnings
        Debug.Log("Fuel alerter enabled");
    }

    public void SetOtherCarHandling(OtherCarHandling handling)
    {
        // Configure how to handle other trains
        // OtherCarHandling values: Stop, Proceed, Emergency
        Debug.Log($"Other car handling set to: {handling}");
    }

    public void EnableCrossingSignals(AutoEngineerCrossingSignaler signaler)
    {
        if (signaler == null) return;

        // Configure crossing signal behavior
        Debug.Log("Crossing signal handler enabled");
    }

    public void GetAutoEngineerConfig(AutoEngineerConfig config)
    {
        if (config == null) return;

        // Access configuration settings
        Debug.Log("Reading Auto Engineer configuration");
    }
}
```

--------------------------------

### Configure WhistleController Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/RollingStock/Steam/WhistleController.md

This C# code snippet defines the Configure method for the WhistleController class, which accepts a WhistleComponent as a parameter. This method is likely used to initialize or set up the whistle functionality.

```csharp
public void Configure(WhistleComponent whistleComponent)
```

--------------------------------

### Download Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Webservices/Results/Photo.md

This snippet displays the signature for the 'Download' method of the 'Photo' class. It takes a string 'key' and optional integers for 'maxWidth' and 'maxHeight', returning a 'RealWorldTerrainGooglePlacePhoto' object. This method is presumably used to download photo data.

```csharp
public RealWorldTerrainGooglePlacePhoto Download(string key, int? maxWidth = null, int? maxHeight = null)
```

--------------------------------

### Define SetLensColors Method in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Effects/MarkerLamp.md

This snippet defines the SetLensColors method for the MarkerLamp class. This public method accepts an array of LensColor objects as input, likely to configure the lamp's lens colors.

```csharp
public void SetLensColors(LensColor[] aspects)
```

--------------------------------

### ApplyToBalance Method - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/Industry.md

The `ApplyToBalance` method allows for applying a specified amount to the industry's balance. It accepts parameters for the total amount, category, an optional memo, count, and a quiet flag for silent application.

```csharp
public void ApplyToBalance(int total, Ledger.Category category, string memo = null, int count = 0, bool quiet = false)
```

--------------------------------

### Declare SoftMenu Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/SoftMenu.md

This snippet shows the declaration of the SoftMenu class in C#. It inherits from MonoBehaviour and implements the INavigationView interface, indicating it's a Unity component with navigation capabilities.

```csharp
public class SoftMenu : MonoBehaviour, INavigationView
```

--------------------------------

### Declare MultiplayerHostMenu Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/MultiplayerHostMenu.md

Declares the MultiplayerHostMenu class, inheriting from BuilderMenuBase. This class is part of the UI.Menu namespace and is defined in MultiplayerHostMenu.cs.

```csharp
public class MultiplayerHostMenu : BuilderMenuBase
```

--------------------------------

### Config Class Properties (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Config.md

Exposes a static `Shared` property of type `Config`, allowing global access to the configuration instance. This is a common pattern for singleton-like access in Unity.

```csharp
public static Config Shared;
```

--------------------------------

### Destroy Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Webservices/RealWorldTerrainWebServiceBase.md

This snippet defines the abstract Destroy method signature within the RealWorldTerrainWebServiceBase class. This method is intended to be implemented by derived classes to handle resource cleanup.

```csharp
public abstract void Destroy()
```

--------------------------------

### InteractiveBookWindow Static Property (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Scripting/Interactive/InteractiveBookWindow.md

Defines the static property 'Shared' for the InteractiveBookWindow class, likely providing a singleton instance.

```csharp
public static InteractiveBookWindow Shared { get; }
```

--------------------------------

### Declare NewGameMenu Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/NewGameMenu.md

This snippet shows the declaration of the NewGameMenu class, which inherits from BuilderMenuBase. It is part of the UI.Menu namespace and is defined in NewGameMenu.cs.

```csharp
public class NewGameMenu : BuilderMenuBase
```

--------------------------------

### ApplyCompleted Method for Delivery Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Progression/Delivery.md

This C# code snippet defines the 'ApplyCompleted' method for the 'Delivery' class. This method is used to signify that a delivery has been successfully completed, likely triggering associated game logic or progression updates. It takes no arguments and returns void.

```csharp
public void ApplyCompleted()
```

--------------------------------

### Declare Copyright Class in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/Utils/Copyright.md

Defines the basic structure of the Copyright class within the InfinityCode.RealWorldTerrain.Utils namespace. This class serves as a fundamental component for managing copyright information.

```csharp
public class Copyright
```

--------------------------------

### KeyForMesh Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/RollingStock/LoadModels/AggregateLoadModelPool.md

Defines the signature for the private static KeyForMesh method. This method is intended to generate a unique key based on mesh atlas index, intended size, and LOD, likely for caching or lookup purposes.

```csharp
private static string KeyForMesh(int atlasIndex, Vector2 intendedSize, int lod)
```

--------------------------------

### Declare BuilderPhoto Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Equipment/BuilderPhoto.md

This C# code snippet shows the declaration of the BuilderPhoto class, which inherits from MonoBehaviour. This class is part of the UI.Equipment namespace and is likely used in a Unity game development context.

```csharp
public class BuilderPhoto : MonoBehaviour
```

--------------------------------

### Config Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Config.md

Defines the `Config` class, inheriting from `ScriptableObject`. This class is intended to hold configuration settings for the game, accessible via a static `Shared` property.

```csharp
public class Config : ScriptableObject
```

--------------------------------

### GetEarlyLateString Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/AI/AutoEngineerPassengerStopper.md

This C# code snippet defines the signature for the 'GetEarlyLateString' method within the AutoEngineerPassengerStopper class. This private static method is likely used internally to format strings related to train arrival or departure times based on an offset in minutes.

```csharp
private static string GetEarlyLateString(int offsetMinutes)
```

--------------------------------

### NoteDestination Method Signature in C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/Destination.md

This snippet provides the signature for the 'NoteDestination' method. This private method likely handles the logic for noting a destination, taking station code, arrival time, transfer count, and train name as parameters.

```csharp
private bool NoteDestination(string stationCode, GameDateTime arrivalTime, int transferCount, string trainName)
```

--------------------------------

### C# IndustryLoaderBase Class Declaration

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Ops/IndustryLoaderBase.md

Declares the abstract class IndustryLoaderBase, inheriting from IndustryComponent. This class serves as a base for industry-specific loaders.

```csharp
public abstract class IndustryLoaderBase : IndustryComponent
```

--------------------------------

### InteractiveBookWindow Properties (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Scripting/Interactive/InteractiveBookWindow.md

Lists the public properties of the InteractiveBookWindow class, such as IsShown, Text, Title, Message, Value, Style, CustomDisplay, OnPlayerClosed, WindowIdentifier, and DefaultSize.

```csharp
public bool IsShown { get; }
```

```csharp
public string Text { get; }
```

```csharp
public string Title { get; }
```

```csharp
public string Message { get; }
```

```csharp
public float Value { get; }
```

```csharp
public GoalStyle Style { get; }
```

```csharp
public string CustomDisplay { get; }
```

```csharp
public Action OnPlayerClosed { get; }
```

```csharp
public string WindowIdentifier { get; }
```

```csharp
public Vector2Int DefaultSize { get; }
```

--------------------------------

### TryGetSceneryDefinition Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Helpers/SceneryAssetManager.md

This C# method, TryGetSceneryDefinition, attempts to retrieve a SceneryDefinition object using a string identifier. It returns a boolean indicating success or failure and outputs the SceneryDefinition if found. This is a common pattern for safe retrieval of data.

```csharp
public bool TryGetSceneryDefinition(string identifier, out SceneryDefinition sceneryDefinition)
```

--------------------------------

### Declare PrimeMoverAudioPlayer Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/PrimeMoverAudioPlayer.md

This snippet shows the declaration of the PrimeMoverAudioPlayer class in C#. It inherits from MonoBehaviour and implements the IPrimeMoverAudioPlayer interface, suggesting its role in managing audio within a Unity game environment.

```csharp
public class PrimeMoverAudioPlayer : MonoBehaviour, IPrimeMoverAudioPlayer
```

--------------------------------

### Configure FlarePickable Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/FlarePickable.md

The Configure method for the FlarePickable class. It takes a string representing the flare's ID and a PlayerId indicating who placed it. This method is essential for initializing the flare's state.

```csharp
public void Configure(string flareId, PlayerId placedBy)
```

--------------------------------

### PrefabStore Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Model/Database/PrefabStore.md

Declares the PrefabStore class, which implements the IDisposable and IPrefabStore interfaces. This class is designed for managing prefab stores within the application.

```csharp
public class PrefabStore : IDisposable, IPrefabStore
```

--------------------------------

### Declare RealWorldTerrainPrefsBase Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/InfinityCode/RealWorldTerrain/RealWorldTerrainPrefsBase.md

This snippet shows the basic declaration of the RealWorldTerrainPrefsBase class within the InfinityCode.RealWorldTerrain namespace. It serves as the foundational structure for terrain preference settings in the RealWorldTerrain system.

```csharp
public class RealWorldTerrainPrefsBase
```

--------------------------------

### VolumeForSqueal Method Signature (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Audio/AudioSourcePair.md

Defines the signature for the private VolumeForSqueal method within the AudioSourcePair class. This method calculates volume based on curvature, velocity, and squeal parameters.

```csharp
private float VolumeForSqueal(float curvature, float maxCurvature, float absVelocity, float maxVelocityForCurve, float squeal)
```

--------------------------------

### Declare CarPlacement Class - C#

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Game/Progression/CarPlacement.md

This snippet shows the declaration of the CarPlacement class in C#. It is part of the Game.Progression namespace and is defined in SetupDescriptor.cs.

```csharp
public class CarPlacement
```

--------------------------------

### StationWindow Class Declaration (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/StationWindow/StationWindow.md

Declares the StationWindow class, which inherits from MonoBehaviour and implements the IBuilderWindow interface. This class is likely part of a Unity UI system for managing station-related windows.

```csharp
public class StationWindow : MonoBehaviour, IBuilderWindow
```

--------------------------------

### Declare BuilderMenuBase Class (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/UI/Menu/BuilderMenuBase.md

Declares the abstract BuilderMenuBase class, inheriting from MonoBehaviour and implementing the INavigationView interface. This class is intended to be a base for UI menu components.

```csharp
public abstract class BuilderMenuBase : MonoBehaviour, INavigationView
```

--------------------------------

### SetOn Method (C#)

Source: https://github.com/tacticalcatboy/railroader-api-docs/blob/main/docs/api/Effects/NightLightController.md

This C# method, SetOn, is part of the NightLightController class and is designed to control the on/off state of a light, taking a boolean parameter to determine its state.

```csharp
private void SetOn(bool on)
```
Tokens:
Raw