Building a Module

partial class Program : MyGridProgram
{
    private Mother mother;

    public Program()
    {
        // Create Mother instance
        mother = new Mother(this);

        // Register module with Mother
        mother.RegisterModules(new List<IExtensionModule> { 
            new MissileGuidanceModule(mother),
            ...
        });
    }
}

class MissileGuidanceModule : BaseExtensionModule
{
    public void Boot()
    {
        // Register commands
        RegisterCommand(new LaunchCommand())
        RegisterCommand(new DetonateCommand())

        // Subscribe to events
        Subscribe<WaypointReachedEvent>();
        Subscribe<ReadyForLaunchEvent>();

        // Boot activities
        ConfigureWarheads();
    }
}

class MissileGuidanceModule : BaseExtensionModule
{
    // Runs every program cycle automatically
    public void Run()
    {
        // Update the current position of the missile
        DetermineCurrentPosition();

        // Update the thrusters based on the current position
        UpdateThrusters();

        // Check if we are within the terminal range
        if(IsWithinTerminalRange())
        {   
            ArmWarheads();
        }
    }
}

public class LaunchCommand : BaseModuleCommand
{
    // The name of the command
    public string Name => "launch";
    // or we can use a namespace to organize our 
    // commands by function or block   
    public string Name => "missile/launch";
}

public class LaunchCommand : BaseModuleCommand
{
    MissileGuidanceModule Module;

    public LaunchCommand(MissileGuidanceModule module)
    {
        Module = module;
    }
}

public class LaunchCommand : BaseModuleCommand
{
    public string Execute(TerminalCommand command)
    {
        // first argument
        string targetCoordinate = command.Arguments[0];

        // second argument as a double
        double detonationDistance;
        double.TryParse(command.Arguments[1], out detonationDistance);

        // get an option ie. --maxSpeed=50
        string maxSpeed = command.GetOption("maxSpeed");

        // call InitiateLaunch() method on parent module. The parent will 
        // handle the core launch logic and may fire an event 
        // that other modules can listen for.
        bool success = Module.InitiateLaunch(
            targetCoordinate, 
            detonationDistance, 
            maxSpeed
        );

        // return a message to the terminal for the player
        if(success)
            return "Missile Launched!";
        else
            return "Missile Launch Failed!";
    }
}

public class MissileGuidanceModule : BaseExtensionModule
{
    public void Boot()
    {
        // Register command with access to the current module
        RegisterCommand(new LaunchCommand(this));
    }
}

    public void Launch()
    {
        // Emit the event using the event Type, and event data  
        object eventData;
        Emit<MissileLaunchedEvent>(eventData);

        // Or, we can emit without event data (nice a simple!)
        Emit<MissileLaunchedEvent>();
    }

public class WarheadModule : BaseExtensionModule
{
    // Subscribe to the event during boot
    public override void Boot()
    {
        Subscribe<MissileLaunchedEvent>();
    }
 
    // Handle the event when it is emitted by this, or another module
    public override void HandleEvent(IEvent e, object eventData)
    {
        if(e is MissileLaunchedEvent) {
           Mother.Print("Missile has launched, arming warhead!");

           ArmWarhead();
        }
    }

    void ArmWarhead() {
        // Red light, green light
    }
}

public class MissileGuidanceModule : BaseExtensionModule
{
    public void Boot()
    {
        // Get the Block Catalogue core module
        BlockCatalogue BlockCatalogue = Mother.GetModule<BlockCatalogue>()

        // Get all thrusters on the grid
        List<IMyThrust> thrusters = BlockCatalogue
            .GetBlocks<IMyThrust>();

        // or, only get blocks where name contains a key
        List<IMyThrust> thrusters = BlockCatalogue
            .GetBlocks<IMyThrust>(block => block.CustomName.Contains("door"));
    }
}

public class MissileGuidanceModule : BaseExtensionModule
{
    public void Boot()
    {
        // Get the Block Catalogue core module
        BlockCatalogue BlockCatalogue = Mother.GetModule<BlockCatalogue>()

        // Get the thrusters in the group "Booster Thrusters"
        List<IMyThrust> thrusters = BlockCatalogue
            .GetBlocksByName<IMyThrust>("Booster Thrusters");

        // or, get a specific block by name
        IMyThrust retroThruster = BlockCatalogue
            .GetBlocksByName<IMyThrust>("RetroThruster")
            .firstOrDefault();

        // or even via a tag
        IMyThrust taggedThruster = BlockCatalogue
            .GetBlocksByName<IMyThrust>("#tagged-thruster")
            .firstOrDefault();
    }
}

const float HINGE_OPEN_ANGLE = 45f; // degrees
const string STATE = "READY_FOR_LAUNCH";

public void InitiateLaunch(
    string targetCoordinate, 
    double detonationDistance, 
    float maxSpeed
)
{
    // Get the hinge blocks
    var hinges = Mother.GetModule<BlockCatalogue>()
        .GetBlocksByName<IMyMotorStator>("ExhaustHinges")

    // Set target, detonation distance, and max speed
    // ...

    // Open exhaust flaps
    hinges.ForEach(hinge => {
        Mother.GetModule<ActivityMonitor>()
            .RegisterBlock(
                // we pass in the hinge block
                hinge,
                // We specify the condition to run 
                // against the hinge each cycle
                // ie. has it reached the desired angle?
                block => HingeAtDesiredAngle(
                    block as IMyMotorStator, 
                    HINGE_OPEN_ANGLE
                ),
                // we specify the action to take when the above condition is 
                // true, which can access the block if desired
                // ie. the hinge has reached the desired angle
                block => LaunchMissile()
            );
    });
}

void LaunchMissile()
{
    // We ensure that launch can only be called once since multiple hinges 
    // will call this method as they reach their terminal position. The 
    // ability to monitor the aggregate completion of a group of 
    // blocks will come in a future update.
    if(LAUNCH_STATE == "LAUNCH")
        return;

    LAUNCH_STATE = "LAUNCH";
    
    // logic to start thrusters, engage autopilot, etc...
}

public void Boot()
{
    // Register connectors and monitor the Status property which 
    // tells us if the connector is connected or not.
    RegisterBlockTypeForStateMonitoring<IMyShipConnector>(
        // We specify the block's property to monitor (Status)
        connector => connector.Status, 
        // We specify the action to take when the block's state changes
        (block, newState) => HandleConnectorStateChange(
            block as IMyShipConnector, 
            newState
        );
    );
}

public void HandleConnectorStateChange(IMyShipConnector connector, object newState)
{
    // We cast the new state to the specific type we are monitoring
    var status = newState as MyShipConnectorStatus?;

    if(status.hasValue)
    {
        switch(newState)
        {
            // The connector is now connected
            case ConnectorStatus.Connected:
                Emit<ConnectorLockedEvent>(connector);
                break;
                
            // The connector is now disconnected
            case ConnectorStatus.Unconnected:
                Emit<ConnectorUnlockedEvent>(connector)
                break;
        }
    }
}