Integration

Eleven steps to get CrimsonCore booting in your project. Steps 7 (Game Instance) and 8 (Default Input Component) are the most common sources of silent-failure bugs - don't skip them.

Requires every Crimson plugin

CrimsonCore is free to download, but compiles only with all Crimson plugins installed. Tick them alongside it in step 1.

1. Enable the plugin

Open Edit -> Plugins, type Crimson in the search box, tick CrimsonCore's checkbox (plus the Crimson plugins it depends on - the Plugins window flags them as required), and restart the editor when prompted. For a Blueprint project that's the entire install - you never hand-edit the .uproject or any .Build.cs.

Blueprint-only project?

Enabling the plugin in Edit -> Plugins is the whole installation - there is no .uproject or .Build.cs to edit. The editor writes the plugin entry for you. The C++ step below is needed only when you reference CrimsonCore types from your own C++ code.

C++ projects: after enabling the plugin above, add its module to your build file so your game code can use its types:

csharp

// YourGame.Build.cs
PublicDependencyModuleNames.Add("CrimsonCore");

2. Set the Asset Manager class

UCrimsonAssetManager is the boot entry point. Without it, the gameplay cue manager is never initialized and UCrimsonGameData::Get() will fatal. In Config/DefaultEngine.ini add:

ini

[/Script/Engine.Engine]
AssetManagerClassName=/Script/CrimsonCore.CrimsonAssetManager

Alternatively: Project Settings -> Engine -> General Settings -> Asset Manager Class Name -> /Script/CrimsonCore.CrimsonAssetManager.

3. Configure Game Data, Default Pawn Data, and Logging

Open Project Settings -> Crimson -> Crimson Core and set:

Setting	Description
Game Data Path	Soft ref to your `UCrimsonGameData` data asset. Loaded once at boot.
Default Pawn Data	Fallback `UCrimsonPawnData` used when a player's PlayerState has no PawnData.
Verbose Logging	When on, `CRIMSON_LOG_VERBOSE` / `_INFO` / `_DISPLAY` print to the log. Warnings, Errors, and Fatals always print. Off by default; turn on while diagnosing CrimsonCore behavior.

Create the GameData asset

In the Content Browser, right-click -> Miscellaneous -> Data Asset -> pick CrimsonGameData. Assign your global Damage, Heal, ShieldRegenCooldown, and DynamicTag GameplayEffects. The AttributeMetadata field is optional. No PrimaryAssetTypesToScan registration is needed - the asset is loaded directly by path.

4. Set the Gameplay Cue Manager class

Tells GAS to use UCrimsonGameplayCueManager. Without this setting the boot-time cue preload is skipped and gameplay cues will not fire:

ini

[/Script/GameplayAbilities.AbilitySystemGlobals]
GlobalGameplayCueManagerClass=/Script/CrimsonAbilitySystem.CrimsonGameplayCueManager

5. Set the GameFeature policy class

Registers the cue-path observer so gameplay cue paths declared in GameFeature plugins are picked up at feature registration time:

ini

[/Script/GameFeatures.GameFeaturesSubsystemSettings]
GameFeaturesManagerClassName=/Script/CrimsonExperience.CrimsonGameFeaturePolicy

6. Set the WorldSettings class

Allows each level to specify a default experience via ACrimsonWorldSettings:

ini

[/Script/Engine.Engine]
WorldSettingsClassName=/Script/CrimsonCore.CrimsonWorldSettings

7. Set base classes in Project Settings

Setting	Value
Default Game Mode	`ACrimsonGameMode` (or subclass)
Default Game State	`ACrimsonGameState`
Default Player State	`ACrimsonPlayerState`
Default Player Controller	`ACrimsonPlayerController`
Default Pawn	None - driven by `UCrimsonPawnData` inside the experience
Game Instance	`B_CrimsonGameInstance` (shipped, `/CrimsonCore/System/`), or your own subclass of CrimsonCommon's `UCrimsonCommonGameInstance`

Init states register themselves

The pawn init-state chain (InitState.Spawned -> DataAvailable -> DataInitialized -> GameplayReady, then every Crimson.SystemReady.* feature state) is registered with UGameFrameworkComponentManager by CrimsonCore's game instance subsystem, whatever Game Instance class you pick. Use B_CrimsonGameInstance (/CrimsonCore/System/) for the shipped setup; UCrimsonCommonGameInstance is Abstract, so a C++ project that prefers its own class creates a concrete subclass of it.

8. Set the default Input Component class

UCrimsonHeroComponent::InitializePlayerInput casts the pawn's InputComponent to UCrimsonInputComponent to bind native input actions and ability inputs. If the engine creates a plain UEnhancedInputComponent because the project default is unset, the cast fails (ensureMsgf) and gameplay abilities never get bound. In Config/DefaultInput.ini:

ini

[/Script/Engine.InputSettings]
DefaultInputComponentClass=/Script/CrimsonInput.CrimsonInputComponent

Changes require an editor restart

DefaultInputComponentClass is cached once at editor startup. After changing the ini, restart the editor before re-running PIE - otherwise the engine will continue spawning the previously-cached class.

9. Create an ExperienceDefinition

Create a UCrimsonExperienceDefinition data asset. Set DefaultPawnData to a UCrimsonPawnData asset that references your input config, camera mode, and ability set. Add GameFeatureActions. Assign the asset in your level's ACrimsonWorldSettings -> DefaultExperience.

10. Configure the PlayerCameraManager

In your GameMode constructor, assign ACrimsonPlayerCameraManager so the UI camera priority system works:

cpp

AMyGameMode::AMyGameMode()
{
    PlayerCameraManagerClass = ACrimsonPlayerCameraManager::StaticClass();
}

11. Register actors with GameFrameworkComponentManager

ACrimsonCharacter, ACrimsonPlayerState, and HUD classes do this automatically. Any custom actor that should receive GFA component additions must call:

cpp

UGameFrameworkComponentManager::AddGameFrameworkComponentReceiver(this);    // BeginPlay (or PreInitializeComponents)
UGameFrameworkComponentManager::RemoveGameFrameworkComponentReceiver(this); // EndPlay