Steam input and platform services

#include "Nodes/Input/SIK_InputLibrary.h"

bool StartInput(FSIK_InputActionSetHandle &Gameplay, FSIK_InputDigitalActionHandle &Jump)
{
    if (!USIK_InputLibrary::Init(false))
        return false;
    Gameplay = USIK_InputLibrary::GetActionSetHandle(TEXT("Gameplay"));
    Jump = USIK_InputLibrary::GetDigitalActionHandle(TEXT("Jump"));
    if (Gameplay.Result != 0 && Jump.Result != 0)
        return true;
    USIK_InputLibrary::Shutdown();
    return false;
}

bool IsJumpHeld(FSIK_InputHandle Controller, FSIK_InputDigitalActionHandle Jump)
{
    const auto Data = USIK_InputLibrary::GetDigitalActionData(Controller, Jump);
    return Data.bActive && Data.bState;
}

TArray<bool> ReadJumpForControllers(FSIK_InputActionSetHandle Gameplay,
                                    FSIK_InputDigitalActionHandle Jump)
{
    TArray<FSIK_InputHandle> Controllers;
    const int64 Count = USIK_InputLibrary::GetConnectedControllers(Controllers);
    TArray<bool> Held;
    Held.Reserve(static_cast<int32>(Count));
    for (int32 Index = 0; Index < Count && Index < Controllers.Num(); ++Index)
    {
        USIK_InputLibrary::ActivateActionSet(Controllers[Index], Gameplay);
        Held.Add(IsJumpHeld(Controllers[Index], Jump));
    }
    return Held;
}

TArray<FString> ReadJumpPrompts(FSIK_InputHandle Controller, FSIK_InputActionSetHandle Gameplay,
                                FSIK_InputDigitalActionHandle Jump)
{
    TArray<TEnumAsByte<ESIK_InputActionOrigin>> Origins;
    USIK_InputLibrary::GetDigitalActionOrigins(Controller, Gameplay, Jump, Origins);
    TArray<FString> Paths;
    Paths.Reserve(Origins.Num());
    for (const auto Origin : Origins)
        Paths.Add(USIK_InputLibrary::GetGlyphForActionOrigin(Origin));
    return Paths;
}

bool OpenControllerBindings(FSIK_InputHandle Controller)
{
    return USIK_InputLibrary::ShowBindingPanel(Controller);
}

bool StopSteamInput()
{
    return USIK_InputLibrary::Shutdown();
}

Call ReadJumpForControllers each input update after successful setup. It uses the returned controller count because the array can contain unused slots. IsJumpHeld returns held state; detect its rising edge for a single press. Prompt paths are local image files, not Unreal textures.

#include "Nodes/Screenshots/SIK_ScreenshotsLibrary.h"
#include "Nodes/Timeline/SIK_TimelineLibrary.h"

void CaptureVictory()
{
    USIK_ScreenshotsLibrary::TriggerScreenshot();
    USIK_TimelineLibrary::SetTimelineGameMode(ESIK_TimelineGameMode_Playing);
    USIK_TimelineLibrary::AddTimelineEvent(TEXT("steam_achievement"), TEXT("Victory"),
                                           TEXT("Match won"), 100, 0.0f, 0.0f,
                                           ESIK_TimelineEventClipPriority_Featured);
}

Join handlers take (TEnumAsByte<ESIK_Result>, FSIK_PartyBeaconID, FSIK_SteamId, FString); create handlers take (TEnumAsByte<ESIK_Result>, FSIK_PartyBeaconID); slot-update handlers take (TEnumAsByte<ESIK_Result>). Reservation handlers take (FSIK_PartyBeaconID, FSIK_SteamId).

Get the Parties subsystem from your GameInstance. Store the created beacon only after ResultOK; if creation fails, remove your reservation delegate. Confirm a reservation from your game’s player-arrival handler.

#include "SteamIntegrationKit.h"
#include "Nodes/Parties/SIK_JoinParty_AsyncFunction.h"
#include "Nodes/Parties/SIK_CreateBeacon_AsyncFunction.h"
#include "Nodes/Parties/SIK_ChangeNumOpenSlots_AsyncFunction.h"
#include "Nodes/Parties/SIK_PartiesLibrary.h"
#include "Nodes/Parties/SIK_PartiesSubsystem.h"

void RefreshBeaconLocations(TArray<FSIK_SteamPartyBeaconLocation> &AvailableLocations)
{
    AvailableLocations.Reset();
    int32 Count = 0;
    if (!USIK_PartiesLibrary::GetNumAvailableBeaconLocations(Count) ||
        !USIK_PartiesLibrary::GetAvailableBeaconLocations(Count, AvailableLocations))
    {
        UE_LOG(LogSIK, Warning, TEXT("Beacon locations unavailable; refresh to retry"));
        return;
    }
    for (const FSIK_SteamPartyBeaconLocation &Location : AvailableLocations)
    {
        TEnumAsByte<ESIK_SteamPartyBeaconLocationType> Type;
        FString Name;
        if (USIK_PartiesLibrary::GetBeaconLocationData(Location, Type, Name))
            UE_LOG(LogSIK, Log, TEXT("%s"), *Name);
        else
            UE_LOG(LogSIK, Warning,
                   TEXT("Location name unavailable; the location is still selectable"));
    }
    UE_LOG(LogSIK, Log, TEXT("Found %d locations"), AvailableLocations.Num());
}

void InspectPartyBeacon(FSIK_PartyBeaconID Beacon)
{
    FSIK_SteamId Creator;
    FSIK_SteamPartyBeaconLocation Location;
    FString Metadata;
    if (!USIK_PartiesLibrary::GetBeaconDetails(Beacon, Creator, Location, Metadata))
    {
        UE_LOG(LogSIK, Warning, TEXT("Beacon details unavailable; refresh the beacon list"));
        return;
    }
    UE_LOG(LogSIK, Log, TEXT("%s"), *Metadata);
    TEnumAsByte<ESIK_SteamPartyBeaconLocationType> Type;
    FString Name;
    if (USIK_PartiesLibrary::GetBeaconLocationData(Location, Type, Name))
        UE_LOG(LogSIK, Log, TEXT("%s"), *Name);
    else
        UE_LOG(LogSIK, Warning, TEXT("Location name unavailable"));
}

TArray<FSIK_PartyBeaconID> ListPartyBeacons()
{
    int32 Count = 0;
    USIK_PartiesLibrary::GetNumActiveBeacons(Count);
    TArray<FSIK_PartyBeaconID> Beacons;
    Beacons.Reserve(Count);
    for (int32 Index = 0; Index < Count; ++Index)
        Beacons.Add(USIK_PartiesLibrary::GetBeaconByIndex(Index));
    return Beacons;
}

bool AdvertiseParty(USIK_PartiesSubsystem *Parties, const FSIK_SteamPartyBeaconLocation &Location,
                    const FString &ConnectString, const FScriptDelegate &Reservation,
                    const FScriptDelegate &Success, const FScriptDelegate &Failure)
{
    if (!IsValid(Parties) || ConnectString.IsEmpty())
        return false;
    auto *Request =
        USIK_CreateBeacon_AsyncFunction::CreateBeacon(3, Location, ConnectString, TEXT("Coop"));
    if (!Request)
        return false;
    Parties->OnReservationNotification.AddUnique(Reservation);
    Request->OnSuccess.Add(Success);
    Request->OnFailure.Add(Failure);
    Request->Activate();
    return true;
}

void ReservedPlayerArrived(FSIK_PartyBeaconID Beacon, FSIK_SteamId Player)
{
    USIK_PartiesLibrary::OnReservationCompleted(Beacon, Player);
}

bool UpdatePartyOpenSlots(FSIK_PartyBeaconID Beacon, int32 OpenSlots,
                          const FScriptDelegate &Success, const FScriptDelegate &Failure)
{
    if (OpenSlots < 0)
        return false;
    auto *Request = USIK_ChangeNumOpenSlots_AsyncFunction::ChangeNumOpenSlots(Beacon, OpenSlots);
    if (!Request)
        return false;
    Request->OnSuccess.Add(Success);
    Request->OnFailure.Add(Failure);
    Request->Activate();
    return true;
}

bool ClosePartyBeacon(USIK_PartiesSubsystem *Parties, FSIK_PartyBeaconID Beacon,
                      const FScriptDelegate &Reservation)
{
    if (!USIK_PartiesLibrary::DestroyBeacon(Beacon))
        return false;
    if (IsValid(Parties))
        Parties->OnReservationNotification.Remove(Reservation);
    return true;
}

bool JoinBeacon(FSIK_PartyBeaconID Beacon, const FScriptDelegate &Success,
                const FScriptDelegate &Failure)
{
    auto *Request = USIK_JoinParty_AsyncFunction::JoinParty(Beacon);
    if (!Request)
        return false;
    Request->OnSuccess.Add(Success);
    Request->OnFailure.Add(Failure);
    Request->Activate();
    return true;
}

#include "Nodes/Utils/SIK_UtilsLibrary.h"
#include "Nodes/Networking/SIK_NetworkingLibrary.h"
#include "Nodes/Networking/SIK_NetworkingSubsystem.h"

int32 ActiveSteamAppId()
{
    return USIK_UtilsLibrary::GetAppID().AppID;
}

bool WatchCustomPeer(USIK_NetworkingSubsystem *Networking, const FScriptDelegate &RequestHandler)
{
    if (!IsValid(Networking))
        return false;
    Networking->OnP2PSessionRequest.AddUnique(RequestHandler);
    return true;
}

bool AcceptExpectedPeer(FSIK_SteamId Requested, FSIK_SteamId Expected)
{
    return USIK_SharedFile::IsEqualSteamId(Requested, Expected) &&
           USIK_NetworkingLibrary::AcceptP2PSessionWithUser(Requested);
}

bool SendCustomHeartbeat(FSIK_SteamId Peer)
{
    return USIK_NetworkingLibrary::SendP2PPacket(Peer, {1}, 7, P2PSendUnreliable);
}

bool PollCustomHeartbeat(FSIK_SteamId Expected)
{
    int32 Size = 0;
    if (!USIK_NetworkingLibrary::IsP2PPacketAvailable(Size, 7))
        return false;
    TArray<uint8> Bytes;
    FSIK_SteamId Sender;
    if (!USIK_NetworkingLibrary::ReadP2PPacket(Bytes, Size, Sender, 7))
        return false;
    return USIK_SharedFile::IsEqualSteamId(Sender, Expected) && Bytes.Num() == 1 && Bytes[0] == 1;
}

bool StopCustomPeer(USIK_NetworkingSubsystem *Networking, FSIK_SteamId Peer,
                    const FScriptDelegate &RequestHandler)
{
    if (IsValid(Networking))
        Networking->OnP2PSessionRequest.Remove(RequestHandler);
    return USIK_NetworkingLibrary::CloseP2PSessionWithUser(Peer);
}

bool OpenNameKeyboard(int32 X, int32 Y, int32 Width, int32 Height)
{
    return USIK_UtilsLibrary::OpenSteamKeyboard(0, X, Y, Width, Height);
}

The request handler takes (FSIK_SteamId) and calls AcceptExpectedPeer with your stored peer. PollCustomHeartbeat returns true only for a valid heartbeat. Sending success means queued; it does not confirm delivery.

Add SteamWeb to the backend module. Bind a handler taking (bool, FSIK_BaseWebApiResponse) and check the response before parsing its JSON.

#include "Nodes/User/SIK_GetPlayerSummaries.h"

bool QuerySteamPlayers(const FString &ServerKey, const FString &SteamIds,
                       const FScriptDelegate &Completion)
{
    auto *Request = USIK_GetPlayerSummaries::GetPlayerSummaries(ServerKey, SteamIds);
    if (!Request)
        return false;
    Request->OnResponse.Add(Completion);
    Request->Activate();
    return true;
}