### Accessing IMyJumpDrive Properties and Methods (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyJumpDrive

Example of how to interact with an IMyJumpDrive instance in C#. This shows how to get and set the stored power and how to call the Jump method, with an explanation of the 'usePilot' parameter.

```csharp
// Assuming 'jumpDrive' is an instance of IMyJumpDrive

// Get current stored power
float storedPower = jumpDrive.CurrentStoredPower;

// Set stored power (e.g., to 100%)
jumpDrive.CurrentStoredPower = 1.0f;

// Request a jump using the pilot's position as reference
jumpDrive.Jump(true);

// Request a jump using the default ship controller
jumpDrive.Jump(false);
```

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

### Start Building (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyCubeBuilder

Starts the building process. This can be a virtual method or a protected method that takes nullable Vector3I parameters for start build and start remove positions.

```csharp
public virtual void StartBuilding()
```

```csharp
protected void StartBuilding(ref Nullable<Vector3I> startBuild, Nullable<Vector3I> startRemove)
```

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

### Get Quick Start Definitions (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyDefinitionManager

Retrieves a dictionary reader for all quick start definitions, mapping MyDefinitionId to MyQuickStartDefinition. This function provides access to configurations for starting scenarios.

```csharp
public DictionaryValuesReader<MyDefinitionId, MyQuickStartDefinition> GetQuickStartDefinitions()
```

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

### SetupForProjector Method

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.MyObjectBuilder_CubeBlock

The SetupForProjector method is a virtual method used to configure a cube block for projector placement. It does not take any parameters and returns void.

```csharp
public virtual void SetupForProjector()

```

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

### Declare QuickStarts Array in C#

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.MyObjectBuilder_Definitions

This C# snippet shows the declaration for the QuickStarts array in the Space Engineers Mod API. The array is of type MyObjectBuilder_QuickStartDefinition[] and is used for defining quick start scenarios.

```csharp
public MyObjectBuilder_QuickStartDefinition[] QuickStarts
```

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

### MyDoor Methods - Initialization and Scene Management

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyDoor

Details methods related to initializing and managing the MyDoor within the game scene. Includes GetObjectBuilderCubeBlock, Init, OnAddedToScene, and OnRemovedFromScene.

```csharp
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
public override void OnAddedToScene(object source)
public override void OnRemovedFromScene(object source)
```

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

### MyBounds Constructors

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MyBounds

Information on how to create instances of the MyBounds class.

```APIDOC
## MyBounds(Single, Single, Single)

### Description
Initializes a new instance of the MyBounds class with specified minimum, maximum, and default values.

### Method
Constructor

### Parameters
#### Path Parameters
- **min** (System.Single) - Required - The minimum bound.
- **max** (System.Single) - Required - The maximum bound.
- **def** (System.Single) - Required - The default value.

### Request Example
```json
{
  "min": 0.0,
  "max": 100.0,
  "def": 50.0
}
```

### Response
#### Success Response (200)
- **MyBounds** (MyBounds) - An instance of the MyBounds class.

#### Response Example
```json
{
  "min": 0.0,
  "max": 100.0,
  "def": 50.0
}
```
```

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

### Get All Corners

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MyOrientedBoundingBoxD

Fills a provided array with the 3D coordinates of all eight corners of the MyOrientedBoundingBoxD, starting at a specified index. This is useful for rendering or detailed geometric analysis.

```csharp
public void GetCorners(Vector3D[] corners, int startIndex)
```

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

### FindStartingState Method (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.MyCampaignManager

Finds the starting state of a campaign state machine (SM) for initial loading purposes. It takes a MyObjectBuilder_CampaignSM object as input and returns a MyObjectBuilder_CampaignSMNode representing the starting state.

```csharp
public MyObjectBuilder_CampaignSMNode FindStartingState(MyObjectBuilder_CampaignSM stateMachine)
```

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

### LoadWorld Property

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyConfigDedicated

Gets the current world's load path or sets the path for the world to be loaded on the next server start.

```csharp
string LoadWorld { get; set; }
```

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

### MyObjectBuilder_CubeBlock Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.MyObjectBuilder_CubeBlock

Outlines the methods available for the MyObjectBuilder_CubeBlock class. This includes 'Remap' for object remapping with a helper, 'SetupForGridPaste' for preparing blocks for grid pasting, and 'SetupForProjector' for projector-related setup.

```csharp
public virtual void Remap(IMyRemapHelper remapHelper)
```

```csharp
public virtual void SetupForGridPaste()
```

```csharp
public void SetupForProjector()
```

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

### Administrators Property

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyConfigDedicated

Gets or sets a list of administrator Steam IDs for the dedicated server. IDs can be in SteamID format or start with 'STEAM_0:'.

```csharp
List<string> Administrators { get; set; }
```

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

### MyLog Initialization Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Utils.MyLog

Contains methods for initializing the logger with a log file name and application version, including an option to initialize with date-based log naming and age limits.

```csharp
public void Init(string logFileName, StringBuilder appVersionString)
public void InitWithDate(string logNameBaseName, StringBuilder appVersionString, int maxLogAgeInDays)
```

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

### MyDefinitionBase Methods (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyGasTankDefinition

Illustrates common methods available in the MyDefinitionBase class, such as Init, Postprocess, ToString, and CheckDefinitionDLCs. These methods are fundamental for definition management and processing within the modding API.

```csharp
public void Init(MyObjectBuilder_DefinitionBase builder, MyModContext context);
public void Postprocess();
public string ToString();
public bool CheckDefinitionDLCs(String[] dlcSymbols);
public string DescriptionText;
public string[] DLCs;
```

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

### DispatchOnceBeforeFrame Method - C#

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyParallelEntityUpdateOrchestrator

Dispatches update tasks that should only run once before the start of a new frame. This is useful for one-time setup or initialization per frame.

```csharp
public void DispatchOnceBeforeFrame()
```

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

### MyQuickStartDefinition ContentPath Field (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyQuickStartDefinition

Represents the file path to the content associated with the quick start definition. This field is of type System.String.

```csharp
public string ContentPath
```

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

### Get Root Node ID (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MyDynamicAABBTreeD

Retrieves the ID of the root node in the spatial partitioning tree. This is the starting point for many tree traversal operations.

```csharp
public int GetRoot()
```

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

### MyQuickStartDefinition Class Documentation

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyQuickStartDefinition

Provides detailed information about the MyQuickStartDefinition class, its inheritance hierarchy, constructors, fields, and methods within the Sandbox.Definitions namespace.

```APIDOC
## Class MyQuickStartDefinition

### Description
Represents a quick start definition in Space Engineers.

### Inheritance
System.Object
MyDefinitionBase
MyQuickStartDefinition

### Inherited Members
- MyDefinitionBase.Id
- MyDefinitionBase.DisplayNameEnum
- MyDefinitionBase.DescriptionEnum
- MyDefinitionBase.DisplayNameString
- MyDefinitionBase.DescriptionString
- MyDefinitionBase.DescriptionArgs
- MyDefinitionBase.Icons
- MyDefinitionBase.Enabled
- MyDefinitionBase.Public
- MyDefinitionBase.AvailableInSurvival
- MyDefinitionBase.Context
- MyDefinitionBase.Init(MyObjectBuilder_DefinitionBase, MyModContext)
- MyDefinitionBase.Postprocess()
- MyDefinitionBase.GetObjectBuilder()
- MyDefinitionBase.ToString()
- MyDefinitionBase.CheckDefinitionDLCs(String[])
- MyDefinitionBase.DLCs
- MyDefinitionBase.DisplayNameText
- MyDefinitionBase.DescriptionText

### Namespace
Sandbox.Definitions

### Assembly
Sandbox.Game.dll

### Syntax
```csharp
[MyDefinitionType]
public class MyQuickStartDefinition : MyDefinitionBase
```

### Constructors
#### MyQuickStartDefinition()
##### Declaration
```csharp
public MyQuickStartDefinition()
```

### Fields
#### ContentPath
##### Declaration
```csharp
public string ContentPath
```
##### Field Value
Type | Description
---|---
System.String | 

#### GameMode
##### Declaration
```csharp
public MyGameModeEnum GameMode
```
##### Field Value
Type | Description
---|---
MyGameModeEnum |

#### OnlineMode
##### Declaration
```csharp
public MyOnlineModeEnum OnlineMode
```
##### Field Value
Type | Description
---|---
MyOnlineModeEnum |

### Methods
#### Init(MyObjectBuilder_DefinitionBase)
##### Declaration
```csharp
protected override void Init(MyObjectBuilder_DefinitionBase builder)
```
##### Parameters
Type | Name | Description
---|---|---
MyObjectBuilder_DefinitionBase | builder |
##### Overrides
MyDefinitionBase.Init(MyObjectBuilder_DefinitionBase)
```

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

### Get Available Client DLC IDs (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyDLCs

Retrieves a list of DLC application IDs installed on the local game client. This can be used to check which DLCs the current player has access to.

```csharp
ListReader<uint> GetAvailableClientDLCIds()
```

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

### MyVoxelBase Initialization Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyVoxelMap

Provides methods for initializing voxel data, including different overloads for various initialization scenarios.

```APIDOC
## MyVoxelBase Initialization Methods

### Description
Methods for initializing voxel data, supporting different initialization parameters and overrides.

### Methods

#### Init(String, IMyStorage, MatrixD, Boolean)
##### Description
Initializes the voxel base with storage name, storage interface, world matrix, and an optional voxel offset.
##### Method
`public override void Init(string storageName, IMyStorage storage, MatrixD worldMatrix, bool useVoxelOffset = true)`
##### Parameters
- **storageName** (System.String) - Required - The name of the storage.
- **storage** (VRage.Game.Voxels.IMyStorage) - Required - The storage interface.
- **worldMatrix** (MatrixD) - Required - The world matrix for the voxel.
- **useVoxelOffset** (System.Boolean) - Optional - Whether to use voxel offset.

#### Init(MyObjectBuilder_EntityBase)
##### Description
Initializes the voxel base using an entity base object builder.
##### Method
`public override void Init(MyObjectBuilder_EntityBase builder)`
##### Parameters
- **builder** (MyObjectBuilder_EntityBase) - Required - The entity base object builder.

#### Init(MyObjectBuilder_EntityBase, IMyStorage)
##### Description
Initializes the voxel base with an entity base object builder and a storage interface.
##### Method
`public override void Init(MyObjectBuilder_EntityBase builder, IMyStorage storage)`
##### Parameters
- **builder** (MyObjectBuilder_EntityBase) - Required - The entity base object builder.
- **storage** (VRage.Game.Voxels.IMyStorage) - Required - The storage interface.

#### InitVoxelMap(MatrixD, Vector3I, Boolean)
##### Description
Initializes the voxel map with a world matrix, size, and an optional offset.
##### Method
`protected override void InitVoxelMap(MatrixD worldMatrix, Vector3I size, bool useOffset = true)`
##### Parameters
- **worldMatrix** (MatrixD) - Required - The world matrix.
- **size** (Vector3I) - Required - The size of the voxel map.
- **useOffset** (System.Boolean) - Optional - Whether to use offset.
```

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

### Get Sounds from IMySoundBlock (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/SpaceEngineers.Game.ModAPI.Ingame.IMySoundBlock

Example of how to retrieve a list of available sound IDs from an IMySoundBlock instance. This method populates a provided list with sound names.

```csharp
public void GetSounds(List<string> sounds)
{
    // Implementation details would go here, populating the 'sounds' list.
    // Example: sounds.Add("MySoundID");
}
```

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

### MyGameTimer Elapsed Property (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Library.Utils.MyGameTimer

Gets the elapsed time as a MyTimeSpan object. This property provides access to the time that has passed since the timer was started or last reset.

```csharp
public MyTimeSpan Elapsed { get; }
```

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

### MyRefineryDefinition Methods (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyRefineryDefinition

This snippet includes key methods such as BlueprintClassCanBeUsed, Init, and InitializeLegacyBlueprintClasses. These methods handle the logic for blueprint validation, initialization from a builder object, and legacy blueprint setup.

```csharp
protected override bool BlueprintClassCanBeUsed(MyBlueprintClassDefinition blueprintClass)
protected override void Init(MyObjectBuilder_DefinitionBase builder)
protected override void InitializeLegacyBlueprintClasses(MyObjectBuilder_ProductionBlockDefinition ob)
```

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

### MyTransform Constructors

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MyTransform

Details on how to create new instances of the MyTransform class.

```APIDOC
## MyTransform Constructors

### MyTransform(Matrix)

#### Description
Initializes a new instance of the MyTransform class using a Matrix.

### Method
Constructor

### Parameters
- **matrix** (Matrix) - The matrix to initialize the transform with.

### MyTransform(ref Matrix)

#### Description
Initializes a new instance of the MyTransform class using a reference to a Matrix.

### Method
Constructor

### Parameters
- **matrix** (Matrix) - A reference to the matrix to initialize the transform with.

### MyTransform(Vector3)

#### Description
Initializes a new instance of the MyTransform class using a Vector3 for position.

### Method
Constructor

### Parameters
- **position** (Vector3) - The position to initialize the transform with.

### MyTransform(ref Vector3)

#### Description
Initializes a new instance of the MyTransform class using a reference to a Vector3 for position.

### Method
Constructor

### Parameters
- **position** (Vector3) - A reference to the vector representing the position to initialize the transform with.
```

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

### Get Minimum Bounds of Cube Block (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyCargoContainer

Retrieves the minimum coordinates of the bounding box for the cube block within its grid. This defines the starting point of the block's volume.

```csharp
public Vector3I Min { get; }
```

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

### Check for Respawn Ship (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyDefinitionManager

Determines if a respawn ship with the specified ID exists in the game. This is commonly used in scenarios or multiplayer setups to manage player starting points.

```csharp
public bool HasRespawnShip(string id)
```

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

### Init Method

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyThrustDefinition

Documentation for the Init method used to initialize block definitions with a builder object.

```APIDOC
## Init Method

### Description
Initializes a block definition using a provided builder object. This method overrides the base class's Init method.

### Method
`protected override void Init(MyObjectBuilder_DefinitionBase builder)`

### Parameters
#### Path Parameters
- **builder** (MyObjectBuilder_DefinitionBase) - Required - The builder object used for initialization.

### Overrides
- MyFunctionalBlockDefinition.Init(MyObjectBuilder_DefinitionBase)
```

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

### TerminalPropertyExtensions - Property Access (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.Ingame.IMyReflectorLight

Examples of extension methods from TerminalPropertyExtensions for getting and setting various property types on IMyTerminalBlock objects. These include float, boolean, color, and generic types.

```csharp
public static float GetValueFloat(this IMyTerminalBlock block, string propertyName);
public static void SetValueFloat(this IMyTerminalBlock block, string propertyName, float value);
public static bool GetValueBool(this IMyTerminalBlock block, string propertyName);
public static void SetValueBool(this IMyTerminalBlock block, string propertyName, bool value);
public static Color GetValueColor(this IMyTerminalBlock block, string propertyName);
public static void SetValueColor(this IMyTerminalBlock block, string propertyName, Color value);
public static T GetValue<T>(this IMyTerminalBlock block, string propertyName);
public static T GetDefaultValue<T>(this IMyTerminalBlock block, string propertyName);
public static T GetMininum<T>(this IMyTerminalBlock block, string propertyName);
public static T GetMinimum<T>(this IMyTerminalBlock block, string propertyName);
public static T GetMaximum<T>(this IMyTerminalBlock block, string propertyName);
public static void SetValue<T>(this IMyTerminalBlock block, string propertyName, T value);
```

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

### MyReflectorLight Methods - C#

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyReflectorLight

This C# code outlines the methods available for the MyReflectorLight class. It covers initialization, object building, light configuration, model updates, and various update mechanisms, many of which override base class implementations.

```csharp
protected override void CreateTerminalControls()
```

```csharp
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
```

```csharp
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
```

```csharp
protected override void InitLight(MyLight light, Vector4 color, float radius, float falloff)
```

```csharp
public override void OnModelChange()
```

```csharp
public override void UpdateAfterSimulationParallel()
```

```csharp
protected override void UpdateEmissivity(bool force = false)
```

```csharp
protected override void UpdateEnabled(bool state)
```

```csharp
protected override void UpdateIntensity()
```

```csharp
protected override void UpdateRadius(float value)
```

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

### TerminalBlockExtensions - Common Operations (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.Ingame.IMyReflectorLight

Examples of common extension methods provided by TerminalBlockExtensions for interacting with IMyTerminalBlock objects. These methods simplify actions like getting block IDs, applying actions, and checking for inventory.

```csharp
public static long GetId(this IMyTerminalBlock block);
public static void ApplyAction(this IMyTerminalBlock block, string actionName);
public static void ApplyAction(this IMyTerminalBlock block, string actionName, List<TerminalActionParameter> parameters);
public static bool HasAction(this IMyTerminalBlock block, string actionName);
public static bool HasInventory(this IMyTerminalBlock block);
public static IMyInventory GetInventory(this IMyTerminalBlock block, int index);
public static int GetInventoryCount(this IMyTerminalBlock block);
public static bool GetUseConveyorSystem(this IMyTerminalBlock block);
public static void SetUseConveyorSystem(this IMyTerminalBlock block, bool value);
```

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

### Initialize Entity (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyPlanet

Provides methods for initializing various entity types within the game world. Overloaded versions handle different initialization arguments, including storage and builder objects.

```csharp
public void Init(MyPlanetInitArguments arguments)
{
    // Implementation details would go here
}
```

```csharp
public override void Init(MyObjectBuilder_EntityBase builder)
{
    // Implementation details would go here
}
```

```csharp
public override void Init(MyObjectBuilder_EntityBase builder, IMyStorage storage)
{
    // Implementation details would go here
}
```

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

### MyVoxelMap Class Documentation

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyVoxelMap

Details about the MyVoxelMap class, including its inheritance, constructors, properties, and methods.

```APIDOC
## MyVoxelMap Class

### Description
Represents a voxel map entity in Space Engineers.

### Namespace
Sandbox.Game.Entities

### Assembly
Sandbox.Game.dll

### Syntax
```csharp
public class MyVoxelMap : MyVoxelBase, IMyVoxelDrawable, IMyDecalProxy, IMyEventProxy, IMyEventOwner, IMyVoxelMap, IMyVoxelBase, IMyEntity, IMyEntity
```

### Constructors
#### MyVoxelMap()
##### Declaration
```csharp
public MyVoxelMap()
```

### Properties
#### IsStaticForCluster
##### Declaration
```csharp
public bool IsStaticForCluster { get; set; }
```

##### Property Value
Type | Description
---|---
System.Boolean | Indicates if the voxel map is static for clustering.

#### RootVoxel
##### Declaration
```csharp
public override MyVoxelBase RootVoxel { get; }
```

##### Property Value
Type | Description
---|---
MyVoxelBase | The root voxel of this voxel map.
##### Overrides
MyVoxelBase.RootVoxel

#### Storage
##### Declaration
```csharp
public override VRage.Game.Voxels.IMyStorage Storage { get; set; }
```

##### Property Value
Type | Description
---|---
VRage.Game.Voxels.IMyStorage | The storage interface for voxel data.
##### Overrides
MyVoxelBase.Storage

### Methods
#### BeforeDelete()
##### Declaration
```csharp
protected override void BeforeDelete()
```

##### Overrides
MyVoxelBase.BeforeDelete()

#### GetFriendlyName()
##### Declaration
```csharp
public override string GetFriendlyName()
```

##### Returns
Type | Description
---|---
System.String | The friendly name of the voxel map.
##### Overrides
MyEntity.GetFriendlyName()

#### GetIntersectionWithAABB(ref BoundingBoxD)
##### Declaration
```csharp
public override bool GetIntersectionWithAABB(ref BoundingBoxD aabb)
```

##### Parameters
Type | Name | Description
---|---|---
BoundingBoxD | aabb | The bounding box to check for intersection.

##### Returns
Type | Description
---|---
System.Boolean | True if an intersection occurs, false otherwise.
##### Overrides
MyEntity.GetIntersectionWithAABB(ref BoundingBoxD)

#### GetIntersectionWithSphere(ref BoundingSphereD)
##### Declaration
```csharp
public override bool GetIntersectionWithSphere(ref BoundingSphereD sphere)
```

##### Parameters
Type | Name | Description
---|---|---
BoundingSphereD | sphere | The bounding sphere to check for intersection.

##### Returns
Type | Description
---|---
System.Boolean | True if an intersection occurs, false otherwise.
##### Overrides
MyEntity.GetIntersectionWithSphere(ref BoundingSphereD)

#### GetNewStorageName(String, Int64)
##### Declaration
```csharp
public static string GetNewStorageName(string storageName, long entityId)
```

##### Parameters
Type | Name | Description
---|---|---
System.String | storageName | The base name for the storage.
System.Int64 | entityId | The ID of the entity.

##### Returns
Type | Description
---|---
System.String | A new, unique storage name.

#### GetObjectBuilder(Boolean)
##### Declaration
```csharp
public override MyObjectBuilder_EntityBase GetObjectBuilder(bool copy = false)
```

##### Parameters
Type | Name | Description
---|---|---
System.Boolean | copy | Whether to create a copy.

##### Returns
Type | Description
---|---
MyObjectBuilder_EntityBase | The object builder for the entity.
##### Overrides
MyVoxelBase.GetObjectBuilder(Boolean)

#### GetOrePriority()
##### Declaration
```csharp
public override int GetOrePriority()
```

##### Returns
Type | Description
---|---
System.Int32 | The ore priority of the voxel map.
##### Overrides
MyEntity.GetOrePriority()
```

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

### Get Content Path - C#

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyGamePaths

Retrieves the absolute path to the original Space Engineers content folder. This is useful for accessing game assets and resources. The path typically points to the 'Content' subfolder within the game's installation directory.

```csharp
string contentPath = MyAPIGateway.Paths.ContentPath;
// Example: D:\SteamLibrary\steamapps\common\SpaceEngineers\Content
```

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

### Get Frames Elapsed for NPC Grid (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyNPCGridClaimSessionComponent

Retrieves the number of frames that have elapsed since the countdown started for a specific NPC grid. This method takes the grid's entity ID as input and returns a nullable integer representing the elapsed frames.

```csharp
public Nullable<int> GetFramesElapsed(long gridEntityId)
```

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

### MyDoor Methods - Lifecycle and State Management

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyDoor

Covers essential methods for managing the MyDoor's lifecycle and state. This includes BeforeDelete, CheckIsWorking, Closing, ContactCallbackInternal, EnableContactCallbacks, and IsClosing.

```csharp
protected override void BeforeDelete()
protected override bool CheckIsWorking()
protected override void Closing()
public override void ContactCallbackInternal()
public override bool EnableContactCallbacks()
public override bool IsClosing()
```

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

### MyProductionBlockDefinition Methods (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyProductionBlockDefinition

Provides methods for managing blueprint usage, retrieving input and output blueprint classes, initializing the definition from a builder, and handling legacy blueprint data.

```csharp
protected virtual bool BlueprintClassCanBeUsed(MyBlueprintClassDefinition blueprintClass)
protected virtual List<MyBlueprintClassDefinition> GetInputClasses()
protected virtual List<MyBlueprintClassDefinition> GetOutputClasses()
protected override void Init(MyObjectBuilder_DefinitionBase builder)
protected virtual void InitializeLegacyBlueprintClasses(MyObjectBuilder_ProductionBlockDefinition ob)
public void LoadPostProcess()
```

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

### Start Removing (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyCubeBuilder

Starts the removing process. This can be a virtual method or a protected method that takes nullable Vector3I parameters for start build and start remove positions.

```csharp
protected virtual void StartRemoving()
```

```csharp
protected void StartRemoving(Nullable<Vector3I> startBuild, ref Nullable<Vector3I> startRemove)
```

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

### Turret Targeting and Control (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyLargeTurretBase

This snippet demonstrates how to use methods of the IMyLargeTurretBase interface to control turret targeting and aiming. It includes setting targets, tracking entities with and without prediction, and synchronizing turret orientation.

```csharp
void ControlTurret(IMyLargeTurretBase turret, IMyEntity targetEntity)
{
    // Set target without position prediction
    turret.SetTarget(targetEntity);

    // Track entity with position prediction enabled
    turret.TrackTarget(targetEntity);

    // Synchronize turret's azimuth and elevation
    turret.SyncAzimuth();

    // Enable or disable idle rotation
    turret.EnableIdleRotation = true;
    turret.SyncEnableIdleRotation();

    // Reset targeting to default settings
    turret.ResetTargetingToDefault();

    // Get current target
    IMyEntity currentTarget = turret.Target;

    // Get targeting groups
    List<string> targetingGroups = new List<string>();
    turret.GetTargetingGroups(targetingGroups);
    string group = turret.GetTargetingGroup();

    // Set a specific targeting group
    turret.SetTargetingGroup("MyGroup");

    // Manually set azimuth and elevation
    turret.SetManualAzimuthAndElevation(45.0f, 30.0f);

    // Check turret properties
    bool isUnderControl = turret.IsUnderControl;
    bool canControl = turret.CanControl;
    float range = turret.Range;
    bool isAimed = turret.IsAimed;
    bool hasTarget = turret.HasTarget;
    float elevation = turret.Elevation;
    float azimuth = turret.Azimuth;
    bool isAIEnabled = turret.AIEnabled;
    bool targetMeteors = turret.TargetMeteors;
    bool targetMissiles = turret.TargetMissiles;
    bool targetSmallGrids = turret.TargetSmallGrids;
    bool targetLargeGrids = turret.TargetLargeGrids;
    bool targetCharacters = turret.TargetCharacters;
    bool targetStations = turret.TargetStations;
    bool targetNeutrals = turret.TargetNeutrals;
    bool targetEnemies = turret.TargetEnemies;
}
```

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

### IMyEntity Methods and Properties

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/SpaceEngineers.Game.ModAPI.IMyParachute

Base methods and properties for all entities in the game.

```APIDOC
## IMyEntity Methods and Properties

### Description
Provides fundamental methods and properties for any entity in the game world, including position, components, and bounding volumes.

### Methods
- **GetPosition()**: Gets the world position of the entity.

### Properties
- **Components**: Accesses the entity's components.
- **HasInventory** (Boolean): Indicates if the entity has an inventory.
- **InventoryCount** (Int32): Gets the number of inventories the entity has.
- **Closed** (Boolean): Indicates if the entity is closed.
- **WorldAABB**: Gets the world-axis-aligned bounding box of the entity.
- **WorldAABBHr**: Gets the world-axis-aligned bounding box of the entity (high resolution).
- **WorldVolume**: Gets the world bounding volume of the entity.
- **WorldVolumeHr**: Gets the world bounding volume of the entity (high resolution).
```

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

### DLC Installed Event - C#

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyDLCs

An event that is triggered when a client installs a new DLC. It provides the client's SteamID and the installed DLC's AppID. This event is called on the server when a player connects.

```csharp
event Action<ulong, uint> DLCInstalled
```

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

### Installations Field Declaration (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Common.ObjectBuilders.MyObjectBuilder_PlanetaryEncounters

Declares the 'Installations' field within the MyObjectBuilder_PlanetaryEncounters class. This field is a generic list used to store MyInstallation objects, likely representing installations related to planetary encounters.

```csharp
public List<MyInstallation> Installations
```

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

### MyDoorBase Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyDoorBase

Details the methods available in the MyDoorBase class, including their parameters, return types, and descriptions.

```APIDOC
## MyDoorBase Methods

### ContactCallbackInternal()

- **Description**: Internal callback for contact events.
- **Method**: public virtual void

### CreateSubpartConstraint(MyEntity, out HkFixedConstraintData, out HkConstraint)

- **Description**: Creates a subpart constraint for the door.
- **Method**: protected void
- **Parameters**:
  - **subpart** (MyEntity) - The subpart entity.
  - **constraintData** (out HkFixedConstraintData) - Output parameter for the constraint data.
  - **constraint** (out HkConstraint) - Output parameter for the constraint.

### CreateTerminalControls()

- **Description**: Creates terminal controls for the door.
- **Method**: protected override void
- **Overrides**: Sandbox.Game.Entities.Cube.MyFunctionalBlock.CreateTerminalControls()

### DisposeSubpartConstraint(ref HkConstraint, ref HkFixedConstraintData)

- **Description**: Disposes of a subpart constraint.
- **Method**: protected void
- **Parameters**:
  - **constraint** (ref HkConstraint) - The constraint to dispose.
  - **constraintData** (ref HkFixedConstraintData) - The constraint data to dispose.

### EnableContactCallbacks()

- **Description**: Enables contact callbacks for the door.
- **Method**: public virtual bool
- **Returns**: System.Boolean

### GetObjectBuilderCubeBlock(Boolean)

- **Description**: Gets the object builder for the cube block.
- **Method**: public override MyObjectBuilder_CubeBlock
- **Parameters**:
  - **copy** (System.Boolean) - Optional. If true, a copy is returned.
- **Overrides**: Sandbox.Game.Entities.Cube.MyFunctionalBlock.GetObjectBuilderCubeBlock(System.Boolean)

### Init(MyObjectBuilder_CubeBlock, MyCubeGrid)

- **Description**: Initializes the door block with object builder and cube grid.
- **Method**: public override void
- **Parameters**:
  - **objectBuilder** (MyObjectBuilder_CubeBlock) - The object builder.
  - **cubeGrid** (MyCubeGrid) - The cube grid.
- **Overrides**: Sandbox.Game.Entities.Cube.MyFunctionalBlock.Init(VRage.Game.MyObjectBuilder_CubeBlock, Sandbox.Game.Entities.MyCubeGrid)

### IsClosing()

- **Description**: Checks if the door is currently closing.
- **Method**: public abstract bool
- **Returns**: System.Boolean

### OnOpenChanged(SyncBase)

- **Description**: Handles changes to the open state.
- **Method**: protected virtual void
- **Parameters**:
  - **obj** (VRage.Sync.SyncBase) - The synchronization object.

### SetOpenLocalValue(Boolean)

- **Description**: Sets the local open value of the door.
- **Method**: protected void
- **Parameters**:
  - **value** (System.Boolean) - The desired open state.

### SetOpenRequest(Boolean, Int64)

- **Description**: Requests to open or close the door.
- **Method**: public void
- **Parameters**:
  - **open** (System.Boolean) - True to open, false to close.
  - **identityId** (System.Int64) - The identity ID making the request.

### SetupDoorSubpart(MyEntitySubpart, Int32, Boolean)

- **Description**: Sets up a subpart of the door.
- **Method**: protected static void
- **Parameters**:
  - **subpart** (MyEntitySubpart) - The subpart to set up.
  - **havokCollisionSystemID** (System.Int32) - The Havok collision system ID.
  - **refreshInPlace** (System.Boolean) - Whether to refresh in place.
```

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

### Warhead Start Countdown Method

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.Ingame.IMyWarhead

Initiates the warhead's countdown sequence. Returns true if the countdown started successfully, false if it cannot start (e.g., block not functional) or is already running.

```C#
bool StartCountdown()
```

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

### MyBounds Class Overview

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MyBounds

Details about the MyBounds class, its inheritance, namespace, and assembly.

```APIDOC
## MyBounds Class

### Description
Represents a set of bounds with minimum, maximum, and default values. Used for clamping and normalizing values within a specified range.

### Inheritance
- System.Object
- MyBounds

### Namespace
VRageMath

### Assembly
VRage.Math.dll

### Syntax
```csharp
public sealed class MyBounds : ValueType
```
```

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

### Start Memory Event

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Utils.MyMemoryLogs

Starts a new memory event for timing or tracking purposes. This static method does not require any parameters.

```csharp
public static void StartEvent()
```

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

### MyDoor Class Documentation

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyDoor

Provides detailed information about the MyDoor class, its inheritance, constructors, fields, properties, and methods.

```APIDOC
## MyDoor Class

### Description
Represents a door block in Space Engineers, inheriting from MyDoorBase and implementing various interfaces for functionality and interaction.

### Namespace
Sandbox.Game.Entities

### Assembly
Sandbox.Game.dll

### Syntax
```csharp
public class MyDoor : MyDoorBase, IMyComponentOwner<MyIDModule>, IMyUpgradableBlock, IMyEventProxy, IMyEventOwner, IMySyncedEntity, IMyTieredUpdateBlock, IMyUpdateTimer, IMyTextSurfaceProvider, IMyMultiTextPanelComponentOwner, IMyTextPanelComponentOwner, IMyDoor, IMyFunctionalBlock, IMyTerminalBlock, IMyCubeBlock, IMyEntity
```

### Constructors
#### MyDoor()
##### Declaration
```csharp
public MyDoor()
```

### Fields
#### MaxOpen
##### Declaration
```csharp
public float MaxOpen
```
##### Field Value
Type | Description
---|---
System.Single | 

### Properties
#### DisassembleRatio
##### Declaration
```csharp
public override float DisassembleRatio { get; }
```
##### Property Value
Type | Description
---|---
System.Single | 
##### Overrides
MyCubeBlock.DisassembleRatio

#### OpenRatio
##### Declaration
```csharp
public float OpenRatio { get; }
```
##### Property Value
Type | Description
---|---
System.Single | 

### Methods
#### BeforeDelete()
##### Declaration
```csharp
protected override void BeforeDelete()
```
##### Overrides
MyEntity.BeforeDelete()

#### CheckIsWorking()
##### Declaration
```csharp
protected override bool CheckIsWorking()
```
##### Returns
Type | Description
---|---
System.Boolean | 
##### Overrides
Sandbox.Game.Entities.Cube.MyFunctionalBlock.CheckIsWorking()

#### Closing()
##### Declaration
```csharp
protected override void Closing()
```
##### Overrides
Sandbox.Game.Entities.Cube.MyFunctionalBlock.Closing()

#### ContactCallbackInternal()
##### Declaration
```csharp
public override void ContactCallbackInternal()
```
##### Overrides
MyDoorBase.ContactCallbackInternal()

#### EnableContactCallbacks()
##### Declaration
```csharp
public override bool EnableContactCallbacks()
```
##### Returns
Type | Description
---|---
System.Boolean | 
##### Overrides
MyDoorBase.EnableContactCallbacks()

#### GetObjectBuilderCubeBlock(Boolean)
##### Declaration
```csharp
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
```
##### Parameters
Type | Name | Description
---|---|---
System.Boolean | copy | 
##### Returns
Type | Description
---|---
MyObjectBuilder_CubeBlock | 
##### Overrides
MyDoorBase.GetObjectBuilderCubeBlock(Boolean)

#### Init(MyObjectBuilder_CubeBlock, MyCubeGrid)
##### Declaration
```csharp
public override void Init(MyObjectBuilder_CubeBlock builder, MyCubeGrid cubeGrid)
```
##### Parameters
Type | Name | Description
---|---|---
MyObjectBuilder_CubeBlock | builder | 
MyCubeGrid | cubeGrid | 
##### Overrides
MyDoorBase.Init(MyObjectBuilder_CubeBlock, MyCubeGrid)

#### IsClosing()
##### Declaration
```csharp
public override bool IsClosing()
```
##### Returns
Type | Description
---|---
System.Boolean | 
##### Overrides
MyDoorBase.IsClosing()

#### OnAddedToScene(Object)
##### Declaration
```csharp
public override void OnAddedToScene(object source)
```
##### Parameters
Type | Name | Description
---|---|---
System.Object | source | 
##### Overrides
Sandbox.Game.Entities.Cube.MyFunctionalBlock.OnAddedToScene(System.Object)

#### OnBuildSuccess(Int64, Boolean)
##### Declaration
```csharp
public override void OnBuildSuccess(long builtBy, bool instantBuild)
```
##### Parameters
Type | Name | Description
---|---|---
System.Int64 | builtBy | 
System.Boolean | instantBuild | 
##### Overrides
MyCubeBlock.OnBuildSuccess(Int64, Boolean)

#### OnCubeGridChanged(MyCubeGrid)
##### Declaration
```csharp
public override void OnCubeGridChanged(MyCubeGrid oldGrid)
```
##### Parameters
Type | Name | Description
---|---|---
MyCubeGrid | oldGrid | 
##### Overrides
MyCubeBlock.OnCubeGridChanged(MyCubeGrid)

#### OnEnabledChanged()
##### Declaration
```csharp
protected override void OnEnabledChanged()
```
##### Overrides
Sandbox.Game.Entities.Cube.MyFunctionalBlock.OnEnabledChanged()

#### OnModelChange()
##### Declaration
```csharp
public override void OnModelChange()
```
##### Overrides
Sandbox.Game.Entities.Cube.MyFunctionalBlock.OnModelChange()

#### OnOpenChanged(SyncBase)
##### Declaration
```csharp
protected override void OnOpenChanged(SyncBase obj)
```
##### Parameters
Type | Name | Description
---|---|---
VRage.Sync.SyncBase | obj | 
##### Overrides
MyDoorBase.OnOpenChanged(SyncBase)

#### OnRemovedFromScene(Object)
##### Declaration
```csharp
public override void OnRemovedFromScene(object source)
```
##### Parameters
Type | Name | Description
---|---|---
System.Object | source | 

```

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

### Start Property

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.Contracts.MyContractEscort

Represents the start vector coordinates for the contract. This is a read-only property of type Vector3D.

```csharp
public Vector3D Start { get; }
```

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

### MyLightingBlockDefinition Init Method

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyLightingBlockDefinition

Overrides the Init method from MyFunctionalBlockDefinition to initialize the MyLightingBlockDefinition using a builder object. This method is crucial for setting up the definition based on game data.

```csharp
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
    // ... initialization logic ...
}
```

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

### Get Entity Inventory

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyMotorStator

Retrieves the inventory associated with an entity. You can get the primary inventory or a specific inventory by its index.

```csharp
MyInventoryComponent GetInventory();
```

```csharp
MyInventoryComponent GetInventory(Int32 index);
```

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

### Prepare Collection for Use (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Utils.MyUtils

Prepares a collection for use by ensuring it's not null and potentially initializing it if it meets certain criteria (e.g., implementing ICollection and having a default constructor). This is useful for generic collection handling.

```csharp
public static TCollection PrepareCollection<TCollection, TElement>(ref TCollection collection)
    where TCollection : class, ICollection<TElement>, new()
{
    // Implementation details...
    return collection;
}
```

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

### MyInventoryBase Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.Entity.MyInventoryBase

Includes abstract methods for adding items (Add, AddItems), applying changes (ApplyChanges), and computing item fit (ComputeAmountThatFits).

```csharp
public abstract bool Add(IMyInventoryItem item, MyFixedPoint amount)
public abstract bool AddItems(MyFixedPoint amount, MyObjectBuilder_Base objectBuilder)
public abstract void ApplyChanges(List<MyComponentChange> changes)
public abstract MyFixedPoint ComputeAmountThatFits(MyDefinitionId contentId, float volumeRemoved = 0F, float massRemoved = 0F)
```

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

### Get Red Component of Color (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.Color

Gets or sets the red component value of a Color object. The value is a byte, ranging from 0 to 255.

```csharp
public byte R { get; set; }
```

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

### MyGasTankDefinition Init Method (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyGasTankDefinition

Shows the overridden Init method for MyGasTankDefinition, which is responsible for initializing the definition from a builder object. This method is part of the MyProductionBlockDefinition class.

```csharp
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
    // Initialization logic here
}
```

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

### Get Weather Name (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyWeatherEffects

Gets the subtype name of the weather present at a specified world position. Returns a string representing the weather type.

```csharp
string GetWeather(Vector3D position)
```

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

### IMyJumpDrive Properties and Methods (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyJumpDrive

This snippet demonstrates accessing and utilizing properties and methods of the IMyJumpDrive interface in C#. It covers retrieving stored power and initiating a jump. Note that the Jump method has an optional parameter for using the pilot's position as a reference.

```csharp
public interface IMyJumpDrive : IMyFunctionalBlock, IMyTerminalBlock, IMyCubeBlock, IMyEntity
{
    float CurrentStoredPower { get; set; }
    void Jump(bool usePilot = true);
}
```

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

### Get SteamPort Property

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyConfigDedicated

Gets or sets the Steam port used by the game server. This property is of type System.Int32.

```csharp
int SteamPort { get; set; }
```

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

### MyQuickStartDefinition Class Definition (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Definitions.MyQuickStartDefinition

Defines the MyQuickStartDefinition class, inheriting from MyDefinitionBase. This class is used to define quick start scenarios within the Space Engineers Mod API.

```csharp
public class MyQuickStartDefinition : MyDefinitionBase
```

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

### Get Float Matrix Method

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.MatrixI

Retrieves a Matrix object. This method is likely used to get a matrix representation for transformations or calculations within the game.

```csharp
public Matrix GetFloatMatrix()
```

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

### MyDoorBase Methods

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyDoorBase

Key methods of the MyDoorBase class for managing door functionality. This includes handling contact callbacks, creating and disposing physics constraints, enabling callbacks, retrieving object builders, initialization, checking closing status, and managing the open state.

```csharp
public virtual void ContactCallbackInternal()
```

```csharp
protected void CreateSubpartConstraint(MyEntity subpart, out HkFixedConstraintData constraintData, out HkConstraint constraint)
```

```csharp
protected override void CreateTerminalControls()
```

```csharp
protected void DisposeSubpartConstraint(ref HkConstraint constraint, ref HkFixedConstraintData constraintData)
```

```csharp
public virtual bool EnableContactCallbacks()
```

```csharp
public override MyObjectBuilder_CubeBlock GetObjectBuilderCubeBlock(bool copy = false)
```

```csharp
public override void Init(MyObjectBuilder_CubeBlock objectBuilder, MyCubeGrid cubeGrid)
```

```csharp
public abstract bool IsClosing()
```

```csharp
protected virtual void OnOpenChanged(SyncBase obj)
```

```csharp
protected void SetOpenLocalValue(bool value)
```

```csharp
public void SetOpenRequest(bool open, long identityId)
```

```csharp
protected static void SetupDoorSubpart(MyEntitySubpart subpart, int havokCollisionSystemID, bool refreshInPlace)
```

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

### Get BoundingBox2 Corners

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRageMath.BoundingBox2

Retrieves the corner points of the BoundingBox2. This can be done by getting a new array or populating an existing one, including an unsafe pointer version.

```csharp
public Vector2[] GetCorners()
```

```csharp
public void GetCorners(Vector2[] corners)
```

```csharp
public void GetCornersUnsafe(Vector2* corners)
```

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

### Get WatcherSimulationSpeedMinimum Property

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/VRage.Game.ModAPI.IMyConfigDedicated

Gets the minimum simulation speed threshold for the watcher. This property is of type System.Single and is not currently used.

```csharp
float WatcherSimulationSpeedMinimum { get; set; }
```

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

### Entity Properties and Components (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.ModAPI.IMyLargeTurretBase

This snippet demonstrates accessing general entity information, including position, components, inventory status, and bounding box/volume data.

```csharp
void EntityInfo(IMyEntity entity)
{
    // Get entity position
    Vector3D position = entity.GetPosition();

    // Access entity components
    MyEntityComponentContainer components = entity.Components;

    // Check for inventory
    bool hasInventory = entity.HasInventory;
    int inventoryCount = entity.InventoryCount;

    // Check if entity is closed
    bool isClosed = entity.Closed;

    // Get world bounding box and volume
    BoundingBoxD worldAABB = entity.WorldAABB;
    BoundingBox worldAABBHr = entity.WorldAABBHr;
    MyOrientedBoundingBoxD worldVolume = entity.WorldVolume;
    MyOrientedBoundingBox worldVolumeHr = entity.WorldVolumeHr;
}
```

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

### Get PanelComponent Property (C#)

Source: https://keensoftwarehouse.github.io/SpaceEngineersModAPI/api/Sandbox.Game.Entities.MyCockpit

Gets the MyTextPanelComponent associated with this ship controller. This provides access to text panel functionalities.

```csharp
public MyTextPanelComponent PanelComponent { get; }
```