// Source/MyModule/MyModule.Build.cs
using UnrealBuildTool;

public class MyModule : ModuleRules
{
    public MyModule(ReadOnlyTargetRules Target) : base(Target)
    {
        // PCH settings — use IWYU in UE5
        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
        // Enable strict IWYU (recommended for new modules in UE5)
        bEnforceIWYU = true;

        // Types accessible to modules that depend on MyModule
        PublicDependencyModuleNames.AddRange(new string[]
        {
            "Core",
            "CoreUObject",
            "Engine",
        });

        // Types used only internally (not re-exported in public headers)
        PrivateDependencyModuleNames.AddRange(new string[]
        {
            "Slate",
            "SlateCore",
        });

        // Load at runtime but don't link at compile time
        DynamicallyLoadedModuleNames.Add("OnlineSubsystem");
    }
}

// Expose extra paths to modules that depend on you
PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "Public/Interfaces"));

// Expose extra paths only to this module's own source
PrivateIncludePaths.Add(Path.Combine(ModuleDirectory, "Private/Helpers"));

// Public/MyClass.h
#pragma once
#include "CoreMinimal.h"

class MYMODULE_API FMyClass
{
public:
    void DoSomething();
};

// Standalone exported function
MYMODULE_API void MyFreeFunction();

// UE5 recommended — each file includes exactly what it uses
PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;
bEnforceIWYU = true;

// Legacy — one monolithic PCH (avoid for new modules)
PCHUsage = PCHUsageMode.UseSharedPCHs;

// Private/MyClass.cpp
#include "MyClass.h"       // own header first
#include "Engine/Actor.h"  // only includes this file directly uses

// C++ exceptions — disable unless third-party code requires them
bEnableExceptions = false;

// Runtime type information — disable unless using dynamic_cast
bUseRTTI = false;

// Third-party static libraries shipped with the engine
AddEngineThirdPartyPrivateStaticDependencies(Target, "zlib", "OpenSSL");

// Source/MyGame.Target.cs
using UnrealBuildTool;
using System.Collections.Generic;

public class MyGameTarget : TargetRules
{
    public MyGameTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Game;
        DefaultBuildSettings = BuildSettingsVersion.Latest;
        IncludeOrderVersion = EngineIncludeOrderVersion.Latest;

        // All game modules that UBT should compile
        ExtraModuleNames.AddRange(new string[] { "MyGame", "MyGameUtilities" });
    }
}

// Source/MyGameEditor.Target.cs
public class MyGameEditorTarget : TargetRules
{
    public MyGameEditorTarget(TargetInfo Target) : base(Target)
    {
        Type = TargetType.Editor;
        DefaultBuildSettings = BuildSettingsVersion.Latest;
        IncludeOrderVersion = EngineIncludeOrderVersion.Latest;
        ExtraModuleNames.AddRange(new string[] { "MyGame", "MyGameEditor" });
    }
}

{
    "FileVersion": 3,
    "EngineAssociation": "5.4",
    "Category": "",
    "Description": "",
    "Modules": [
        {
            "Name": "MyGame",
            "Type": "Runtime",
            "LoadingPhase": "Default"
        },
        {
            "Name": "MyGameEditor",
            "Type": "Editor",
            "LoadingPhase": "Default"
        }
    ],
    "Plugins": [
        {
            "Name": "ModelingToolsEditorMode",
            "Enabled": true
        },
        {
            "Name": "MyPlugin",
            "Enabled": true
        }
    ]
}

Source/
  MyModule/
    Public/
      MyModule.h          (optional module interface header)
      MyClass.h
    Private/
      MyModule.cpp        (module registration)
      MyClass.cpp
    MyModule.Build.cs

// Public/MyModule.h
#pragma once
#include "Modules/ModuleManager.h"

class IMyModule : public IModuleInterface
{
public:
    static IMyModule& Get()
    {
        return FModuleManager::LoadModuleChecked<IMyModule>("MyModule");
    }

    static bool IsAvailable()
    {
        return FModuleManager::Get().IsModuleLoaded("MyModule");
    }
};

// Private/MyModule.cpp
#include "MyModule.h"

class FMyModule : public IMyModule
{
public:
    virtual void StartupModule() override
    {
        // Initialize subsystems, register delegates, etc.
    }

    virtual void ShutdownModule() override
    {
        // Unregister delegates, clean up
    }
};

// Use IMPLEMENT_MODULE for non-gameplay modules
IMPLEMENT_MODULE(FMyModule, MyModule)

// Use IMPLEMENT_GAME_MODULE for modules containing UObject/gameplay code
// IMPLEMENT_GAME_MODULE(FMyModule, MyModule)

// Use IMPLEMENT_PRIMARY_GAME_MODULE for the main game module
// IMPLEMENT_PRIMARY_GAME_MODULE(FMyModule, MyGame, "MyGame")

{
    "Name": "MyModule",
    "Type": "Runtime",
    "LoadingPhase": "Default"
}

Plugins/
  MyPlugin/
    MyPlugin.uplugin
    Source/
      MyPlugin/
        Public/
          IMyPlugin.h
        Private/
          MyPlugin.cpp
        MyPlugin.Build.cs
      MyPluginEditor/           (optional editor-only module)
        Public/
        Private/
          MyPluginEditor.cpp
        MyPluginEditor.Build.cs
    Content/                    (optional, for content plugins)
    Resources/
      Icon128.png

{
    "FileVersion": 3,
    "Version": 1,
    "VersionName": "1.0",
    "FriendlyName": "My Plugin",
    "Description": "Does something useful.",
    "Category": "Gameplay",
    "CreatedBy": "MyStudio",
    "CreatedByURL": "",
    "DocsURL": "",
    "MarketplaceURL": "",
    "CanContainContent": true,
    "IsBetaVersion": false,
    "IsExperimentalVersion": false,
    "Installed": false,
    "Modules": [
        {
            "Name": "MyPlugin",
            "Type": "Runtime",
            "LoadingPhase": "Default"
        },
        {
            "Name": "MyPluginEditor",
            "Type": "Editor",
            "LoadingPhase": "Default"
        }
    ]
}

// MyPlugin.Build.cs — runtime module
public class MyPlugin : ModuleRules
{
    public MyPlugin(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine" });

        // Editor-only dependency, only when compiling an editor build
        if (Target.bBuildEditor)
        {
            PrivateDependencyModuleNames.Add("UnrealEd");
        }
    }
}

// MyPluginEditor.Build.cs — editor module
public class MyPluginEditor : ModuleRules
{
    public MyPluginEditor(ReadOnlyTargetRules Target) : base(Target)
    {
        PCHUsage = PCHUsageMode.UseExplicitOrSharedPCHs;

        PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "UnrealEd" });
        PrivateDependencyModuleNames.Add("MyPlugin");
    }
}